集合

集合

一、集合概念
对象的容器，实现了对对象的常用的操作，类似数组功能
二、集合与数组的区别
（1）数组长度固定，集合长度不固定
（1）数组可以存储基本类型和引用类型，集合只能存储引用类型

三、基本使用

public class Demo1 {
    public static void main(String[] args) {
        //创建集合
        Collection collection = new ArrayList();
        //添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        System.out.println("元素个数："+collection.size());
        System.out.println(collection);
        //删除元素
        collection.remove("榴莲");
        System.out.println("元素个数："+collection.size());
        System.out.println(collection);
        // 遍历元素(使用foreach)
        for (Object object : collection) {
            System.out.println(object);
        }
        // 遍历元素(使用迭代器，hasnext();有没有下一个元素；next();获取下一个元素，remove();删除当前元素)
        Iterator it = collection.iterator();
        while (it.hasNext()){
            String s =(String)it.next();
            System.out.println(s);
        }
        // 判断有没有某个元素
        System.out.println(collection.contains("西瓜"));
        // 判断集合是否为空
        System.out.println(collection.isEmpty());
        
    }
}

元素个数：3
[苹果, 西瓜, 榴莲]
元素个数：2
[苹果, 西瓜]
苹果
西瓜
苹果
西瓜
true
false

public class Demo2 {
    public static void main(String[] args) {
        // 新建 collection
        Collection collection = new ArrayList();
        // 创建学生对象
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",22);
        Student s3 = new Student("王五",24);
        // 添加元素
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println("元素个数"+collection.size());
        System.out.println(collection);
        // 删除
        collection.remove(s1);
        System.out.println("删除之后："+collection);
        // 遍历 (foreach 方法)
        for (Object object:collection) {
            Student s = (Student) object;
            System.out.println(s.toString());
        }
        // 遍历元素(使用迭代器，hasnext();有没有下一个元素；next();获取下一个元素，remove();删除当前元素)
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
            Student s = (Student) iterator.next();
            System.out.println(s.toString());
        }
        // 判断有没有某个元素
        System.out.println(collection.contains(s2));
        // 判断集合是否为空
        System.out.println(collection.isEmpty());
    }
}

元素个数3
[Student{name='张三', age=20}, Student{name='李四', age=22}, Student{name='王五', age=24}]
删除之后：[Student{name='李四', age=22}, Student{name='王五', age=24}]
Student{name='李四', age=22}
Student{name='王五', age=24}
Student{name='李四', age=22}
Student{name='王五', age=24}
true
false

List 子接口

一、特点：有序、有下标、元素可重复。
遍历可以从前往后，也可以从后往前

public class Demo3 {
    public static void main(String[] args) {
        //创建集合对象
        List list = new ArrayList<>();
        // 1.添加元素
        list.add("苹果");
        list.add("小米");
        list.add(0,"华为");
        System.out.println("元素个数"+list.size());
        System.out.println(list);
        // 删除元素
        list.remove("苹果");
        list.remove(0);
        System.out.println("删除之后元素个数:"+list.size());
        System.out.println(list);
        list.add("苹果");
        list.add("小米");
        list.add(0,"华为");
        // 遍历for
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        // 遍历 foreach
        for (Object object:list) {
            System.out.println(object);
        }
        // 遍历 使用迭代器
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //遍历 使用listIterator<>

        ListIterator lit = list.listIterator();
        System.out.println("-----使用listIterator 从前往后迭代 ------");
        while (lit.hasNext()){
            System.out.println(lit.next());
        }
        System.out.println("-----使用listIterator 从后往前迭代 ------");
        while (lit.hasPrevious()){
            System.out.println(lit.previous());
        }
        // 判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());
        // 获取位置
        System.out.println(list.indexOf("小米"));
    }
}

元素个数3
[华为, 苹果, 小米]
删除之后元素个数:1
[小米]
华为
小米
苹果
小米
华为
小米
苹果
小米
华为
小米
苹果
小米
-----使用listIterator 从前往后迭代 ------
华为
小米
苹果
小米
-----使用listIterator 从后往前迭代 ------
小米
苹果
小米
华为
true
false
1

ArrayList

特点：数组结构实现，查询快，增删慢；
jdk1.2以上，运行效率快、线程不安全

public class Demo4 {
    public static void main(String[] args) {
        //创建集合
       ArrayList arrayList = new ArrayList<>();
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",22);
        Student s3 = new Student("王五",24);
       // 添加元素
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数"+arrayList.size());
        System.out.println(arrayList);
        // 删除元素
        arrayList.remove(s1);
        System.out.println("元素个数"+arrayList.size());
        System.out.println(arrayList);
        // 遍历使用迭代器
        System.out.println("------使用迭代器-------");
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s = (Student)it.next();
            System.out.println(s);
        }
        System.out.println("------使用列表迭代器从前往后-------");
        ListIterator lit = arrayList.listIterator();
        while (lit.hasNext()){
            Student s = (Student)lit.next();
            System.out.println(s);
        }
        System.out.println("------使用列表迭代器从后往前-------");
        while (lit.hasPrevious()){
            Student s =(Student)lit.previous();
            System.out.println(s);
        }
        //判断
        System.out.println(arrayList.contains(s1));
        System.out.println(arrayList.isEmpty());
        // 查找
        System.out.println(arrayList.indexOf(s2));
    }
}

元素个数3
[Student{name='张三', age=20}, Student{name='李四', age=22}, Student{name='王五', age=24}]
元素个数2
[Student{name='李四', age=22}, Student{name='王五', age=24}]
------使用迭代器-------
Student{name='李四', age=22}
Student{name='王五', age=24}
------使用列表迭代器从前往后-------
Student{name='李四', age=22}
Student{name='王五', age=24}
------使用列表迭代器从后往前-------
Student{name='王五', age=24}
Student{name='李四', age=22}
false
false
0

LinkeList

特点：链表结构实现，增删快，查询慢。

public class Demo5 {
    public static void main(String[] args) {
        // 创建集合
        LinkedList linkedList = new LinkedList();

        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",22);
        Student s3 = new Student("王五",24);
        // 添加元素
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println("元素个数："+linkedList.size());
        System.out.println(linkedList);
        // 删除元素
        linkedList.remove(s1);
        System.out.println("元素个数"+linkedList.size());
        System.out.println(linkedList);
        // 遍历 使用for
        for (int i=0;i<linkedList.size();i++){
            System.out.println(linkedList.get(i));
                    }
        System.out.println("-----使用foreach 遍历------");
        // 遍历使用foreach
        for (Object object:linkedList) {
            System.out.println(object);
        }
        System.out.println("-----使用迭代器 遍历------");
        Iterator it = linkedList.iterator();
        while (it.hasNext()){
            Student student = (Student)it.next();
            System.out.println(student);
        }
        System.out.println("-----使用list迭代器 遍历------");
        ListIterator lit = linkedList.listIterator();
        while (lit.hasNext()){
            Student student = (Student)lit.next();
            System.out.println(student);
        }
        // 判断
        System.out.println(linkedList.contains(s1));
        System.out.println(linkedList.isEmpty());
        // 获取
        System.out.println(linkedList.indexOf(s2));
    }
}

元素个数：3
[Student{name='张三', age=20}, Student{name='李四', age=22}, Student{name='王五', age=24}]
元素个数2
[Student{name='李四', age=22}, Student{name='王五', age=24}]
Student{name='李四', age=22}
Student{name='王五', age=24}
-----使用foreach 遍历------
Student{name='李四', age=22}
Student{name='王五', age=24}
-----使用迭代器 遍历------
Student{name='李四', age=22}
Student{name='王五', age=24}
-----使用list迭代器 遍历------
Student{name='李四', age=22}
Student{name='王五', age=24}
false
false
0

泛型

1.Java泛型是Java1.5引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
2.常见形式有泛型类、泛型接口、泛型方法。
3. 语法 <T…> T 称为占位符，表示一种引用类型（不一定非要用T，aBc都是可以的,可以写多个，使用逗号隔开，<T,E,P>）
4. 好处：提高代码重用性，防止类型转换异常，提高代码安全性

创建泛型类

package com.company;
/*
*  泛型类
* 语法：类名<T>
* T 是占位符，表示一种引用类型，如果编写多个使用逗号隔开
* */
public class MyGeneric<T> {
    // 使用泛型创建变量
    T t;
    // 泛型作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
    // 使用泛型作为返回值
    public T getT(){
        return t;
    }
}

泛型类

public class testGeneric {
    public static void main(String[] args) {
        // 使用泛型类创建对象
        MyGeneric<String> myGeneric = new MyGeneric<String>();
        myGeneric.t="hello";
        // 给 t 赋非String类型值的时候就会报错；
//        myGeneric.t=2;
        myGeneric.show("大家好");
        String string =  myGeneric.getT();
        System.out.println(string);

        MyGeneric<Integer> myGeneric1 = new MyGeneric<>();
        myGeneric1.t=100;
        // 给 t 赋非Integer类型值的时候就会报错；
//        myGeneric1.t="hello"
        myGeneric1.show(200);
        Integer integer = myGeneric1.getT();
        System.out.println(integer);
    }
}

大家好
hello
200
100

泛型接口

/*
* 泛型接口
* 语法：接口名<T>
* 注意：不能船舰泛型静态常量
* */
public interface Myinterface<T> {
    String name="张三";
    T Server(T t);
}

public class MyinterfaceImpl implements Myinterface<String> {
    @Override
    public String Server(String t) {
        System.out.println(t);
        return t;
    }
}

泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。

特点：编译时即可检查，而非运行时抛出异常；访问时，不必类型转换;不同泛型之间引用不能相互赋值，泛型不存在多态。

未指定数据类型

public class Demo7 {
    public static void main(String[] args) {
        // 在没有约束集合类型时，默认的是Object类型。ArrayList<Object> arrayList = new ArrayList<Object>();
        ArrayList arrayList = new ArrayList();
        arrayList.add("hello world");
        arrayList.add(10);
        arrayList.add(true);
        for (Object object:arrayList) {
            System.out.println(object);
        }
    }
}

hello world
10
true

指定数据类型

public static void main(String[] args) {
        // 在没有约束集合类型时，默认的是Object类型。ArrayList<Object> arrayList = new ArrayList<Object>();
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("hello world");
        // 当我们添加了一个指定的类型后，不是该类型的值将无法添加进去。
        arrayList.add(10);// 手动红色
        // 当我们添加了一个指定的类型后，不是该类型的值将无法添加进去。
        arrayList.add(true);// 手动红色
        for (Object object:arrayList) {
            System.out.println(object);
        }
    }

Set集合

特点：无序、无下标、元素不可重复。

方法：全部继承自Collection中的方法。

HashSet

基于HashCode计算元素存放的位置。
当存入元素的哈希码形同时，会调用equals进行确认，如结构为true，则拒绝后者存入。

    public static void main(String[] args) {
        // 新建集合
        HashSet<String> hashSet = new HashSet<String>();
        // 添加元素
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("王五");
        System.out.println("元素个数:"+hashSet.size());
        System.out.println(hashSet);
        // 重复元素添加不进去，语法也不会报错。
        hashSet.add("张三");
        hashSet.add("李四");
        System.out.println("元素个数:"+hashSet.size());
        System.out.println(hashSet);
        // 删除元素
        hashSet.remove("张三");
        // 遍历元素使用foreach
        System.out.println("----使用foreach遍历-------");
        for (String string:hashSet) {
            System.out.println(string);
        }
        System.out.println("----使用迭代器遍历-------");
        Iterator<String> iterator = hashSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        // 判断
        System.out.println(hashSet.contains("张三"));
        System.out.println(hashSet.isEmpty());
    }

元素个数:3
[李四, 张三, 王五]
元素个数:3
[李四, 张三, 王五]
----使用foreach遍历-------
李四
王五
----使用迭代器遍历-------
李四
王五
false
false

TreeSet

基于排序顺序实现元素不重复
实现了 SortedSet 接口，对集合元素自动排列
元素对象的类型必须实现 Comparable 接口，指定排序规则
通过 CompareTo 方法确定是否为重复元素

map集合

特点：

（1）用于存储任意键值对（Key-Value）
（2）键：无序、无下标、不允许重复（唯一）
（3）值：无序、无下标、允许重复

/*
* Map 接口的使用
* 特点：（1）储存键值对；（2）键不能重复，值可以重复；（3）无序
* */
    public static void main(String[] args) {
        // 创建Map集合
        Map<String,String> map = new HashMap<>();
        // 添加元素
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");
        System.out.println("元素个数："+map.size());
        System.out.println(map);
        System.out.println("可以看出顺序与程序的顺序是不一样的");
        // 删除
        map.remove("usa");
        System.out.println("元素个数："+map.size());
        System.out.println(map);
        // 遍历 使用keySet() 返回此映射中包含的键的 Set视图。;
        System.out.println("------keySet()遍历-------");
        for (String key:map.keySet()) {
            System.out.println(key+"---"+map.get(key));
        }
        System.out.println("------entrySet()遍历-------");
        //   遍历 entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。
        for (Map.Entry<String,String> entry:map.entrySet()) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
        //判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));
    }

元素个数：3
{usa=美国, uk=英国, cn=中国}
可以看出顺序与程序的顺序是不一样的
元素个数：2
{uk=英国, cn=中国}
------keySet()遍历-------
uk---英国
cn---中国
------entrySet()遍历-------
uk---英国
cn---中国
true
false

HashMap

初始容量为16，加载因子为0.75。
JDK1.2 线程不安全，运行效率快，允许用null 作为key或是value；

package com.company;
/*
* HashMap 集合
* 储存结构：hash表（数组+链表+红黑树）
* 使用key的hashcode 和 equals 作为元素是否重复的依据。
* */

import java.util.HashMap;
import java.util.Map;

public class Demo10 {
    public static void main(String[] args) {
        // 创建集合
        HashMap<Student,String> students = new HashMap<Student,String>();
        // 添加元素
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",22);
        Student s3 = new Student("王五",24);
        students.put(s1,"北京");
        students.put(s2,"上海");
        students.put(s3,"广州");
        System.out.println("元素个数"+students.size());
        System.out.println(students);
        // 删除
        students.remove(s1);
        System.out.println("元素个数"+students.size());
        System.out.println(students);
        // 遍历 使用keySet();
        System.out.println("-------使用keySet()遍历-------");
        for (Student key:students.keySet()){
            System.out.println(key.toString()+"==="+students.get(key));
        }
        // 遍历 使用 entrySet() 遍历;
        System.out.println("-------使用entrySet()遍历-------");
        for (Map.Entry<Student,String> entry: students.entrySet()) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
        // 判断
        // 没有重写hashcode 和 equals 之前，new Student（）尽管属性值一样，系统没有以哪一个属性判断依据的标准，
        // 所有开辟了一个新的地址去存储。值虽然一样，指针不一样。
        // 所以没有重写hashcode 和 equals 之前，这条语句永远打印 false，意味在集合中找不到王五，实际上是有的。
        // 在 Student.java 中生成hashcode 和 equals后，打印就为 true，意味着在集合中能够找到王五，实际上是有的。
        System.out.println(students.containsKey(new Student("王五",24)));

        System.out.println(students.containsValue("上海"));
    }
}

{Student{name='张三', age=20}=北京, Student{name='李四', age=22}=上海, Student{name='王五', age=24}=广州}
元素个数2
{Student{name='李四', age=22}=上海, Student{name='王五', age=24}=广州}
-------使用keySet()遍历-------
Student{name='李四', age=22}===上海
Student{name='王五', age=24}===广州
-------使用entrySet()遍历-------
Student{name='李四', age=22}---上海
Student{name='王五', age=24}---广州
true
true

在Student.java 中重写hashcode 和 equals ；作为元素在集合中是否重复的判断依据

TreeMap

实现了 SortedMap接口(是Map的子接口)，可以对key自动排序。

/*
* TreeMap的使用
* 存储结构：红黑树
* 要求：key对应的类必须实现 Comparable<接口>
* */
public class Dome11 {
    public static void main(String[] args) {
        // 创建集合
        TreeMap<Student,String> treeMap = new TreeMap<Student,String>();
        // 添加元素
        Student s1 = new Student("张三",24);
        Student s2 = new Student("李四",26);
        Student s3 = new Student("王五",22);
        treeMap.put(s1,"北京");
        treeMap.put(s2,"山海");
        treeMap.put(s3,"深证");
        System.out.println("元素个数："+treeMap.size());
        System.out.println(treeMap);
        //Exception in thread "main" java.lang.ClassCastException: com.company.Student cannot be cast to java.lang.Comparable
        // 注意 TreeMap 因为要对key自动排序，所以key一定要有排序规则，key对应的类要去实现 Comparable<接口>
        treeMap.put(new Student("赵六",22),"南京");
        // 我们定义了以年龄作为排序根节点，所以同一个节点不会出现两次，之后添加的该节点的值会替换原来节点的值。
        System.out.println(treeMap);
        // 删除
        treeMap.remove(new Student("王五",22),"南京");
        System.out.println(treeMap);
        // 遍历 使用keySet
        System.out.println("------使用keySet（）遍历-------");
        for (Student key:treeMap.keySet()) {
            System.out.println(key+"="+treeMap.get(key));
        }
        System.out.println("------使用entrySet（）遍历-------");
        for (Map.Entry<Student,String> entry:treeMap.entrySet()) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
        // 判断
        System.out.println(treeMap.containsKey(new Student("张三",24)));
    }
}

元素个数：3
{Student{name='王五', age=22}=深证, Student{name='张三', age=24}=北京, Student{name='李四', age=26}=山海}
{Student{name='王五', age=22}=南京, Student{name='张三', age=24}=北京, Student{name='李四', age=26}=山海}
{Student{name='张三', age=24}=北京, Student{name='李四', age=26}=山海}
------使用keySet（）遍历-------
Student{name='张三', age=24}=北京
Student{name='李四', age=26}=山海
------使用entrySet（）遍历-------
Student{name='张三', age=24}=北京
Student{name='李四', age=26}=山海
true