ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

集合

2022-08-06 22:03:33  阅读:20  来源: 互联网

标签:java util add static 集合 import public


为什么需要集合

自动扩容,实现无限存放数据(只要服务器够用)

单列(List、set)和多列(map)

ArrayList,LinkedList存数据保证有序

迭代器

集合专有

package jihe;

import java.util.ArrayList;
import java.util.Iterator;

/**
 *
 **/
public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("111");
        strings.add("111");
        strings.add("111");
        strings.add("111");
        strings.add("111");
//        for (int i = 0; i < strings.size(); i++) {
//            System.out.println(strings.get(i));
//
//        }
        /**
         * 迭代器
         */
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

}

手写迭代器

package jihe;

import java.util.List;

/**
 *
 **/
public class MyIterator {
    List list;
    public MyIterator(List list){
        this.list=list;
    }
    int count=0;
    public Object next(){
        return list.get(count++);//get后加1
    }
    public Boolean hasnext(){
        if(count < list.size()) {
            return true;
        }else{
            return false;
        }
    }
}

增强for循环用于数组和集合

package jihe;

import java.util.ArrayList;

/**
 *
 **/
public class Demo3 {
    public static void main(String[] args) {
        int[] arrList={1,2,3,4,5,6};
        //泛型只用于应用类,基本数据使用其包装类
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(5);
        for (int i :
                arrList) {
            System.out.println(i);
        }
        for (Integer i :
                arrayList) {
            System.out.println(i);
        }
    }
}

泛型

jdk1.5没有泛型,ArrayLitsnew类型为Object

泛型用于接口,类,方法

【泛型类】

package jihe;

/**
 *泛型类
 **/
public class MyFanXin <T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}
package jihe;

/**
 *
 **/
public class Demo4 {
    public static void main(String[] args) {
        //指定String类型
        MyFanXin<String> stringMyFanXin = new MyFanXin<>();
        stringMyFanXin.setT("aa");
        //指定Integer类型
        MyFanXin<Integer> integerMyFanXin = new MyFanXin<>();
        integerMyFanXin.setT(11);
    }
}

【泛型方法】

package jihe;

/**
 *泛型方法
 **/
public class Demo5 {
    public <T> T show(T t){//返回值不固定可以写一个泛型类最哦为返回对象
        return t;

    }}
package jihe;

/**
 *
 **/
public class Demo4 {
    public static void main(String[] args) {
        Demo5 demo5 = new Demo5();
        demo5.show("a");
        demo5.show(1);
        
    }
}

【泛型接口】

package jihe;

/**
 *
 **/
public interface Demo6<T> {
    T show(T t);
}
package jihe;

/**
 *
 **/
public class Demo7<T> implements Demo6<T>{
    @Override
    public T show(T t) {
        return null;
    }
}
package jihe;

/**
 *
 **/
public class Demo8 {
    public static void main(String[] args) {
        Demo7<String> stringDemo7 = new Demo7<>();
        stringDemo7.show("33");
    }
}

同时使用泛型接口和泛型方法

package jihe;

/**
 *
 **/
public interface Demo6<T> {
    <M> T show(T t,M m);
}
package jihe;

/**
 *
 **/
public class Demo7<T> implements Demo6<T>{
    @Override
    public <M> T show(T t, M m) {
        System.out.println(m);
        return null;
    }
}
package jihe;

/**
 *
 **/
public class Demo8 {
    public static void main(String[] args) {
        Demo7<String> stringDemo7 = new Demo7<>();
        stringDemo7.show("33",33);//33
    }
}

【通配符】

package jihe;

import java.sql.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 *
 **/
public class Demo9 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        show(strings);

    }

    /**
     * List<?>-->可以接受所有的泛型类型,但是不能做添加方法
     * @param list
     */
    public static void show(List<?> list){
       // list.add("a");
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            iterator.next();
        }
    }
}

通配符上限和下限

package jihe;

import java.util.List;

/**
 *
 **/
public class Demo10 {
    public static void main(String[] args) {

    }
    //上限:接受类型为MyIterator或者其子类
    static void show(List<? extends MyIterator>list){

    }
    //上限:接受类型为MyIterator或者其父类
    static void show2(List<? super MyIterator>list){

    }
}

可变参数

package jihe;

/**
 *可变参数,如果有多个参数,可变参数放在最后
 **/
public class Demo11 {
    public static void main(String[] args) {
        show(1,1,1,1,1);

    }
    public static void show(int... a){
        for (int i :
                a) {
            System.out.println(i);
        }

    }
}

可变参数用法

package jihe;

import java.util.Arrays;
import java.util.List;

/**
 *
 **/
public class Demo11 {
    public static void main(String[] args) {
        show(1,1,1,1,1);
        //Arrays.asList生成的List数量不能发生变化
        List<Integer> integers = Arrays.asList(1, 2, 3, 4);
        for (Integer i :
                integers) {
            System.out.println(i);
        }

    }
    public static void show(int... a){
        for (int i :
                a) {
            System.out.println(i);
        }

    }
}
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

泛型底层擦除机制

package jihe;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 *
 **/
public class Demo11 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("My可");
        list.add(10);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }
    public static void show(int... a){
        for (int i :
                a) {
            System.out.println(i);
        }

    }
}

ArrayList

arraylist按index查找修改效率高

增删效率低

初始化是懒加载:用到是才加载

Linkedlist

双向链表+红黑树

增删效率高,查找效率低O(n)

set

HashSet

  1. HashSet是set接口的典型实现,大多数时候使用Set集合时就是使用这个实现类
  2. HashSet按Hash算法来决定集合元素的顺序,具有很好的查找性能
  3. 当向HashSet集合中存入一个元素时,根据该对象的hashcode值决定该对象在HashSet中的存储位置

hash是什么,是把任意数据通过散列算法变换成固定的输出,该输出就是散列值

package set;

import java.util.HashSet;
import java.util.Set;

/**
 *
 **/
public class HashSetSample {
    public static void main(String[] args) {
        /**
         * hashset无序不重复
         */
        Set<String> strings = new HashSet<>();
        strings.add("131311");
        strings.add("131312");
        strings.add("131331");
        strings.add("1311");
        strings.add("1311");
        strings.add(null);//允许存入null,但只能有一个
        System.out.println(strings);//[131331, 1311, 131312, 131311]无序不重复
        /**
         * get方法属于List,Set无法使用
         */
       // strings.get();
    }
}

LinkedHahSet

LinkedHahSet是HashSet的子类,除HahSet的特性外,他同时使用链表维护元素的次序,可以保证插入顺序提取数据

TreeSet

底层:红黑树

TreeSet是SortedSet接口的实现类,TreeSet可以确保集合元素处于排序状态

TreeSet采用红黑树的数据结构来存储集合元素

TreeSet默认采用自然排序对元素升序排列,也可以实现Comparable接口在定义排序方式

Set集合的数据的唯一性

【问题1】

Set集合在新增数据时先判断hashcode是否已经存在

若hashcode存在调用equals进行值比较;

hashcode与equals都存在时,Set才认为数据已存在,不予新增

【问题2】

为甚什么使用hashcode,直接用equals不好吗?

出于效率考虑

hashcode()返回的整数结果决定了set集合中的存放位置,hashcode()计算速度块,但可能出现哈希碰撞

equals()则对值进行比较,处理速度相对较慢

注意:重写hascode和equals根据需要进行判断

掌握HashSet和TreeSet的应用

package set;

import java.util.LinkedHashSet;

/**
 *
 **/
public class LinkedHashSetSample {
    public static void main(String[] args) {
        LinkedHashSet<String> strings = new LinkedHashSet<>();
        strings.add("1238127789");
        strings.add("1233237789");
        strings.add("1235341894");
        strings.add("4112444149");
        System.out.println(strings);//[1238127789, 1233237789, 1235341894, 4112444149]存储时还是遵循hashset,只是访问有序
    }
}
package set;

import java.util.Comparator;
import java.util.TreeSet;

/**
 *
 **/
public class TreeSetSample {
    static class IntegerComparator implements Comparator<Integer>{

        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;//降序
        }
    }
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>(new IntegerComparator());
        set.add(100);
        set.add(140);
        set.add(180);
        set.add(200);
        System.out.println(set);//有序
    }
}

Map

key和value可以是任何引用类型,但是key通常是String,key不可重复,反复设置key,后面的value会覆盖前面的

HashMap

对key进行无需存储

不能保证数据按存储顺序读取,且key全局唯一

HashMap与LinkedHashMap的区别

package set;

import java.util.HashMap;

/**
 *
 **/
public class HashMapSample {
    public static void main(String[] args) {
        HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
        Object put = stringObjectHashMap.put("name", "张三");
        Object put1 = stringObjectHashMap.put("name", "张");//如果put是出现重复,会返回原来的值
        System.out.println(put1);
    }
}

LinkedHashMap按顺序提取数据

TreeMap

存储key-value时,需要根据key对节点进行排序;

TreeMap支持两种Key排序,自然排序和定制排序

底层:红黑树

package set;

import java.util.Comparator;
import java.util.TreeMap;

/**
 *
 **/
public class TreeMapSample {
    static class Resx implements Comparator<String>{
        @Override
        public int compare(String o1, String o2) {
            return o2.compareTo(o1);
        }//String:按key排序

    }
    public static void main(String[] args) {
        TreeMap<String, Object> stringObjectTreemAP = new TreeMap<String, Object>(new Resx());
        stringObjectTreemAP.put("A1","1");
        stringObjectTreemAP.put("C3","2");
        stringObjectTreemAP.put("B5","3");
        stringObjectTreemAP.put("X1","4");
        stringObjectTreemAP.put("B1","6");
        System.out.println(stringObjectTreemAP);//自然排序{A1=1, B1=6, B5=3, C3=2, X1=4},使用定制排序:{X1=4, C3=2, B5=3, B1=6, A1=1}
    }
}

Map三种遍历方式

for i

foreach

迭代器

package set;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 *
 **/
public class LoopSample {
    public static void main(String[] args) {
        Map<String, Integer> stringIntegerHashMap = new HashMap<>();
        stringIntegerHashMap.put("1",1);
        stringIntegerHashMap.put("a",2);
        stringIntegerHashMap.put("3",3);
        stringIntegerHashMap.put("4",4);
        stringIntegerHashMap.put("5",5);
        stringIntegerHashMap.put("6",6);
        /**
         * foreach
         */
        Set<String> keys= stringIntegerHashMap.keySet();
        for (String s:keys
             ) {
            System.out.println(stringIntegerHashMap.get(s));//获取value
        }
        /**
         * lambda表达式
         */
        stringIntegerHashMap.forEach((key,value)-> System.out.println(key+value));

        /**
         *
         * 迭代器
         */
        Iterator<Map.Entry<String, Integer>> iterator = stringIntegerHashMap.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> next = iterator.next();
            System.out.println(next.getKey());
            System.out.println(next.getValue());
        }
    }
}

通过Conllections实现集合的排序

package set;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 *
 **/
public class ListSort {
    class SampleCompartor implements Comparator<Integer>{
        /**
         * o1-o2
         * 结果>0,则交换位置
         * 结果=0或<0不变
         * @param o1
         * @param o2
         * @return
         */
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;
        }
    }
    public List<Integer> sort(List<Integer> list){
        Collections.sort(list,new SampleCompartor());
        System.out.println(list);
        return list;
    }
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(70);
        arrayList.add(90);
        arrayList.add(30);
        arrayList.add(50);
        ListSort listSort = new ListSort();
        List<Integer> sort = listSort.sort(arrayList);
        System.out.println(sort);
        System.out.println(arrayList);
    }
}

自定义对象比较器

比较器内容-->o1.比较属性(如果属性为String).compleTo(o2.属性)

标签:java,util,add,static,集合,import,public
来源: https://www.cnblogs.com/yhdxx/p/16557981.html

专注分享技术,共同学习,共同进步。侵权联系[admin#icode9.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有