1三、Java的集合

时间 2019-11-22

标签 java 集合栏目 Java 繁體版

原文原文链接

数组和集合的区别：数组

一、数组的长度是固定的，集合的长度是可变的安全

二、数组中存储的是同一类型的元素，能够存储基本数据类型值。集合存储的都是对象，并且对象的类型能够不一致。数据结构

Collection：因此单列集合的父接口，定义了单列集合通用的一些方法工具

示例代码：this

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("读者A");
        boolean b2=coll.add("读者B");
        System.out.println(coll);

        boolean b3=coll.remove("读者C");
        boolean b4=coll.remove("读者B");
        boolean b5=coll.contains("读者A");
        boolean b6=coll.isEmpty();
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        System.out.println(b6);
        System.out.println(coll.size());
        System.out.println(coll.toArray()[0]);

    }
}

iterator ：迭代器接口，迭代，就是collection集合元素的通用获取方式。在取元素以前先要判断集合中有没有元素，若是有，就把这个元素取出来，继续判断，若是还有就再取出来，一直到集合中的全部元素都取出。对象

示例代码：索引

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("读者A");
        boolean b2=coll.add("读者B");
        Iterator<String> it = coll.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

加强for循环：底层使用迭代器，使用for循环的格式，简化迭代器书写，用来遍历集合和数组接口

格式： for（集合/数组的数据类型变量名：集合名/数组名）{方法体}rem

示例代码：get

public class Demo {
    public static void main(String [] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);

        boolean b1=coll.add("读者A");
        boolean b2=coll.add("读者B");
        for (String str:coll) {
            System.out.println(str);
        }
    }
}

注意：加强for循环的目标只能是集合或者数组

泛型：是一种未知的数据类型，当咱们不知道使用什么数据类型的时候，可使用泛型 E e :Element 元素，T t :Type 类型

建立集合，不使用泛型：

好处：集合不使用泛型，默认类型就是Object类型，能够存储任意类型的数据

坏处：不安全，容易引起异常

建立集合，使用泛型：

好处：一、避免了类型转换的麻烦，存储的是什么数据，取出的就是什么类型

二、把运行期间的异常提高到了编译期间

坏处：泛型是什么类型，只能存储什么类型的数据

定义一个泛型的类：修饰符 class 类名<表明泛型的变量>{}

定义一个泛型的方法：修饰符 <泛型> 返回值类型方法名（参数列表（使用泛型））{方法体}，含有泛型的方法在调用方法的时候肯定泛型的数据类型，参数传递什么类型，泛型就是什么类型

定义一个泛型的接口：修饰符 interface 接口名<泛型>{}

含义泛型的接口的使用方式：一、定义接口的实现类，实行接口，指定接口的泛型

二、接口使用什么泛型，实现类就使用什么泛型

泛型通配符：当使用泛型类或者接口时，传递的数据中，泛型的类型不肯定，能够经过通配符<?>表示。可是一旦使用了泛型通配符后，只能使用Object类中的共性方法，集合中的元素自身方法没法使用

示例代码

public class Demo {
    public static void main(String[] args){}
    
    private class Demo2<E>{
        private E name;

        public E getName() {
            return name;
        }

        public void setName(E name) {
            this.name = name;
        }
        
        public <M> void method(M m){
            
        }
        
        public void printArray(ArrayList<?> list){
            Iterator<?>it = list.iterator();
            while (it.hasNext()){
                System.out.println(it.next());
            }
        }
    }
}

List接口：一、他是一个元素存取有序的集合

二、他是一个带有索引的集合

三、集合中能够有重复的元素

注意：要防止索引的越界异常

示例代码

public class Demo {
    public static void main(String[] args){
        List<String> list =new ArrayList<>();
        list.add("读者A");
        list.add("读者B");
        list.add("读者A");
        System.out.println(list);
        list.add(1,"读者C");
        System.out.println(list);
        list.remove(1);
        System.out.println(list);
        list.set(1,"读者D");
        System.out.println(list);
    }
}

ArrayList：前面已经用过，再也不讲述，底层是数组数据结构

LinkedList：链表数据结构

示例代码

public class Demo {
    public static void main(String[] args){
       LinkedList<String> list = new LinkedList<>();
       list.add("读者A");
       list.add("读者B");
       list.add("读者A");
        System.out.println(list);
       list.addFirst("读者C");
        System.out.println(list);
        list.addLast("读者D");
        System.out.println(list);
        list.push("读者E");
        System.out.println(list);
        list.pop();
        System.out.println(list);
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        list.removeFirst();
        list.removeLast();
    }
}

Vector：底层是数组数据结构，如今多用ArrayList代替使用

Set接口类：一、不容许存储重复的元素

二、没有索引，没有带索引的方法，也不能使用普通的for循环遍历

HashSet实现类：一、不容许存储重复的元素

二、没有索引，没有带索引的方法，也不能使用普通的for循环遍历

三、是一个无序的集合，存储元素和取出元素的顺序有可能不一致

四、底层是一个哈希表结构（查询的速度很是的快）

示例代码：

public class Demo {
    public static void main(String[] args){
       Set<Integer> set = new HashSet<>();
       set.add(96);
       set.add(97);
       set.add(98);
       set.add(99);
       set.add(100);
       set.add(97);
        System.out.println(set);
       Iterator it = set.iterator();
       while (it.hasNext()){
           System.out.println(it.next());
       }
    }
}

扩展：哈希值，是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来获得地址，不是数据实际存储的物理地址）

注意：使用HashSet存储自定义类型的元素时，要重写hashCode和equals方法

LinkedHashSet:HashSet的子类，元素不能够重复，可是有序，底层是一个哈希表+链表

示例代码：

public class Demo {
    public static void main(String[] args){
       LinkedHashSet<Integer> set = new LinkedHashSet<>();
       set.add(96);
       set.add(97);
       set.add(98);
       set.add(99);
       set.add(97);
        System.out.println(set);
        Iterator it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

可变参数：当方法的参数列表数据类型已经肯定，可是参数的个数不肯定，就可使用可变参数，修饰符返回值类型方法名（数据类型...变量名）{},可变参数底层就是一个数组，根据传递的参数个数不一样，会建立不一样长度的数组，来存储这些参数。

public class Demo {
    public static void main(String[] args){
        System.out.println(sum(1,2,3));
        System.out.println(sum(1,2));
    }

    public static int sum (int...a){
        int sum =0;
        for (int b:a) {
            sum+=b;
        }
        return sum;
    }
}

Collections：操做集合的工具类，对集合进行操做

示例代码：

public class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(96);
        list.add(97);
        list.add(98);
        list.add(99);
        list.add(100);
        Collections.shuffle(list);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }
}

Map集合接口：一、Map集合是一个双列集合，一个元素包含两个值（Key，Value）

二、Map集合中的元素，Key和Value的数据类型能够相同也能够不一样

三、Map集合中的元素，Key是不容许重复的，Value是能够重复的

四、Map集合中的元素，Key和Value是一一对应的

HashMap<K,V>，Map接口的实现类：一、底层是哈希表，查询速度快

二、是一个无序的集合，存储元素和取出元素的顺序不一致

LinkedHashMap<K,V>，HashMap的子类：一、底层是哈希表+链表

二、集合是一个有序的集合，存储元素和取出元素的顺序一致

Map接口的示例代码

public class Demo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("读者A","做品A");
        map.put("读者B","做品B");
        map.put("读者C","做品C");
        map.put("读者D","做品D");
        System.out.println(map);
        map.remove("读者D");
        System.out.println(map);
        System.out.println(map.get("读者A"));
        System.out.println(map.containsKey("读者A"));

        Set<String> set =map.keySet();
        Iterator<String> it1 = set.iterator();
        while(it1.hasNext()){
            String str = it1.next();
            System.out.println(map.get(str));
        }

        Set<Map.Entry<String,String >> set2 = map.entrySet();
        Iterator<Map.Entry<String ,String >> it2 = set2.iterator();
        while (it2.hasNext()){
            Map.Entry<String ,String > entry = it2.next();
            System.out.println(entry.getKey()+"="+entry.getValue());
        }




    }
}