Java集合

1、集合基础 1.1、集合概述

集合类的特点：提供一种存储空间可变的存储模型，存储数据容量可以发送改变
集合类有很多，ArrayList
ArrayList:
	1.可调整大小的数组实现
	2.是一种特殊的数据类型，泛型
怎么用：
	1. 在出现E的地方使用引用数据类型替换即可
	2. 举例：ArrayList,ArrayList

2、ArrayList 1.1、ArrayList构造方法和添加方法

方法名	说明
public ArrayList()	创建一个空的集合对象
public boolean add(E a)	将指定的元素添加到此集合的末尾
public void add(int index,E element)	在此集合的指定位置添加指定的元素

import java.util.ArrayList;

public class TextArrayList {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();//创建一个集合
        System.out.println("list:" + list);//输出空列表list:[]
        System.out.println(list.add("hello"));//输出添加成功与否
        System.out.println("list:" + list);//输出list:[hello]
        list.add("world");
        list.add("java");
        System.out.println(list);//[hello, world, java]
        list.add(2,"javaSE");//在指定位置添加元素
        System.out.println(list);//[hello, world, javaSE, java]
        //当前集合里只有4个数据,现在往第6个位置添加数据
        //会报错触发运行时异常
        // IndexOutOfBoundsException: Index: 5, Size: 4
        list.add(5,"javaSE");
        System.out.println(list);

    }
}

1.2、ArrayList集合常用方法

方法名	说明
public boolean remove(Objecto)	删除指定的元素，返回删除是否成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size0	返回集合中的元素的个数

//集合的增删改查
import java.util.ArrayList;

public class TextArrayList2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();//创建一个集合
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);//[hello, world, java]
//        System.out.println(list.remove("world"));//删除指定的元素
//        System.out.println(list);//删除完成[hello, java]

//        System.out.println(list.remove(2));//删除指定索引的元素,并返回被删除的元素：java
//        System.out.println(list);//[hello, world]

//        System.out.println(list.set(1,"世界"));//修改指定索引的元素，并返回被修改的元素：world
//        System.out.println(list);//[hello, 世界, java]

        System.out.println(list.get(1));//获取索引为1的元素，不会改变集合里的元素
        System.out.println(list.size());//获取集合长度
        
        for (String s : list) {//遍历集合
            System.out.println(s);
        }
    }
}

集合的遍历

//集合的遍历
public class TextArrayList3 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();//创建一个集合
        list.add("hello");
        list.add("world");
        list.add("java");

        for (String s : list) {//遍历集合
            System.out.println(s);
        }

        ArrayList people = new ArrayList<>();//创建集合
        people.add(new Person("张三",20));//向集合添加元素
        people.add(new Person("李四",30));
        people.add(new Person("王五",25));

        System.out.println("-----------普通for循环遍历--------------");
        for (int i = 0; i < people.size(); i++) {//普通for循环遍历
            System.out.println(people.get(i));
        }
        System.out.println("-----------增强型for循环遍历--------------");
        for (Person persons : people) {//增强型for循环
            System.out.println(persons);
        }
    }
}
class Person{
    

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

从键盘输入数据保存到集合

import java.util.ArrayList;
import java.util.Scanner;

//集合的遍历
public class TextArrayList4 {
    public static void main(String[] args) {

        ArrayList people = new ArrayList<>();//创建集合
        Scanner scanner = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            Person person = new Person();//创建个人的对象
            System.out.print("输入人员姓名:");
            person.setName(scanner.next());//从键盘获取姓名
            System.out.print("输入人员年龄:");
            person.setAge(scanner.nextInt());//获取年龄
            people.add(person);//添加进集合
        }

        System.out.println("-----------增强型for循环遍历--------------");
        for (Person persons : people) {//增强型for循环
            System.out.println(persons);//这里会默认调用Person对象的toString()方法
        }
        scanner.close();//关闭输入输出接口释放资源
    }
}

3、Collection集合 3.1、 Collection集合创建

Collection是一个接口，所以只能new一个他的子类来实现创建

Collection collection = new ArrayList<>();
//使用方法跟ArrayList类一样

3.2、Collextion 集合的遍历

Iterator：迭代器，集合的专用遍历方式
	1. Iterator iterator();返回此集合的迭代器，通过集合的iterator()方法得到
	2. 迭代器是通过集合的iterator()方法得到的，所以我们说他是依赖于集合而存在的

Iterator中的常用方法
	1. E next(): 返回迭代中的下一个元素
	2. boolean hasNex():如果迭代具有更多元素，则返回true

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

//用迭代器遍历集合中的元素
public class TestCollection {
    public static void main(String[] args) {
        Collection collection = new ArrayList<>();
        collection.add("hello");
        collection.add("world");
        collection.add("java");
        Iterator iterator = collection.iterator();
        //迭代器是一次性的,用完就报废
        while (iterator.hasNext()){//判断集合是否还有元素
            System.out.println(iterator.next());//获取元素
        }
        //迭代器访问越界的元素会抛出异常
        //这个迭代器已经走到头了,再调用一次就会越界
        //System.out.println(iterator.next());//NoSuchElementException
    }
}

4、List 集合

List结合概述
	1. 有序集合(也称为序列)。该界面的用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引 (列表中的位置)访问元素，并搜索列表中的元素。
	2. 与Set集合不同，列表通常允许重复的元素
List集合的特点
	1. 有序：存储和取出的元素顺序一致
	2. 可重复：存储的元素可以重复

List list =new ArrayList<>();
//使用方法跟ArrayList类一样

4.1、List集合的特有方法

方法名	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索弓

4.2、并发修改异常

黑马程序员全套Java教程

4.3、Listlterator

用于允许程序员沿任一-方向遍历列表的列表的迭代器， 在迭代期间修改列表，并获取列表中迭代器的当前位置。AListIterator没有电流元素; 它的光标位置总是位于通过调用previous ()返回的元素和通过调用next ()返回的元素next()。长度为的列表的迭代器具有n+1可能的光标位置

Listlterator:列表迭代器
	1. 通过List集合的listlterator0方法得到， 所以说它是List集合特有的迭代器
	2. 用于允许程序员沿任一方向遍历列表的列表迭代器， 在迭代期间修改列表，并获取列表中迭代器的当前位置
	
Listlterator中的常用方法
	1. E next0: 返回迭代中的下一个元素
	2. boolean hasNext():如果迭代具有更多元素,则返回true
	3. E previous0:返回列表中的上一个元素boolean hasPrevious(: 如果此列表迭代器在相反方向遍历列表时具有更多元素,则返回true
	4. void add(E e):将指定的元素插入列表

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class TestListIterator {
    public static void main(String[] args) {
        List list = new ArrayList<>();//创建有序列表
        list.add("hello");
        list.add("world");
        list.add("java");

        ListIterator listIterator = list.listIterator();//生成迭代器
        System.out.println("------------------正序遍历-----------");
        while (listIterator.hasNext()){//正序遍历
            System.out.println(listIterator.nextIndex());//返回当前元素在列表中的位置
            System.out.println(listIterator.next());
        }
        System.out.println("------------------倒序遍历-----------");
        while (listIterator.hasPrevious()){//倒序遍历
            System.out.println(listIterator.previousIndex());//返回当前元素在列表中的位置
            System.out.println(listIterator.previous());

        }
        System.out.println("------------------添加元素-----------");
        while (listIterator.hasNext()){//正序遍历
            String next = listIterator.next();
            System.out.println(next);
            //listIterator迭代器不会触发并发修改异常,但需要用该迭代器添加元素
            if (next.equals("world")){
                System.out.println("添加元素 ");
                listIterator.add("javaee");//添加之后不会再本次遍历中打印出来
            }
        }
        for (String s : list) {//再遍历一遍就可以打印出来"javaee"
            System.out.println(s);
        }
    }
}

4.4、List队列

	数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关 系的数据元素的集合
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

4.4.1、常见的数据结构之栈

数据进入栈模型的过程称为:压/进栈
数据离开栈模型的过程称为:弹/出栈
栈是一种数据先进后出的模型

4.4.2、常见的数据结构之队列

数据从后端进入队列模型的过程称为：入队列
数据从前端离开队列模型的过程称为：出队列
队列是一种数据先进先出的模型

4.4.3、常见的数据结构之数组

数组是一种查询快，增删慢的模型
查询数据通过索引定位，查询任意数据耗时相同，查询效率高
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

4.4.4、常见的数据结构之链表

链表是-种增删快的模型(对比数组)
链表是一种查询慢的模型(对比数组)
查询数据D是否存在，必须从头(head)开始查询
查询第3个数据，必须从头(head)开始查询

4.4.5、常见的数据结构之哈希表

黑马程序员全套Java教程

4.4.6、 List集合子类特点

List集合常用子类: ArrayList, LinkedList

1. ArrayList: 底层数据结构是数组，查询快，增删慢
2. LinkedList:底层数据结构是链表，查询慢,增删快

5、LinkedList集合 5.1、LinkedList集合的特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst(）	返回此列表中的第一个元素
public E getLast(）	返回此列表中的最后一个元素
public E removeFirst(）	从此列表中删除并返回第一个元素
public E removeLast(）	从此列表中删除并返回最后一个元素

import java.util.LinkedList;

public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList<>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        System.out.println(linkedList);
        System.out.println("-----------添加-------------------");
        linkedList.addFirst("你好");//添加到列表的开头
        linkedList.addLast("世界");//添加到列表的结尾
        System.out.println(linkedList);
        System.out.println("-----------查询-------------------");
        System.out.println(linkedList.getFirst());//返回列表的第一个元素
        System.out.println(linkedList.getLast());//返回列表的最后一个元素
        System.out.println("-----------删除-------------------");
        System.out.println(linkedList.removeFirst());//删除列表的第一个元素并返回
        System.out.println(linkedList.removeLast());//删除列表的最后一个元素并返回
        System.out.println(linkedList);
    }
}

6、Set 集合 6.1、Set集合概述和特点

Set集合特点
	1. 不包含重复元素的集合
	2. 没有带索引的方法，所以不能使用普通for循环遍历

import java.util.HashSet;

public class TestSet {
    public static void main(String[] args) {
        HashSet set = new HashSet<>();//HashSet对集合的顺序无法保证，写进去的和读出来的顺序不一样
        set.add("hello");
        set.add("world");
        set.add("java");

        for (String s : set) {//遍历的元素是随机的，也不算随机根据放入的内容变化
            System.out.println(s);
        }
        System.out.println("-----------添加之后-------------------");
        System.out.println(set.add("hello"));//set集合不包含重复元素，所以它会被丢掉;返回false
        for (String s : set) {//遍历的元素是随机的，也不算随机根据放入的内容变化
            System.out.println(s);
        }
    }
}

6.2、哈希值

哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
	public int hashCode0:返回对象的哈希码值
对象的哈希值特点
1. 同一个对象多次调用hashCode(方法返回的哈希值是相同的
2. 默认情况下，不同对象的哈希值是不同的。而重写hashCode(方法,可以实现让不同对象的哈希值相同

6.3、Hash Set集合概述和特点

HashSet集合特点
1. 底层数据结构是哈希表
2. 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
3. 没有带索引 |的方法,所以不能使用普通for循环遍历
4. 由于是Set集合，所以是不包含重复元素的集合

6.4、L inkedHashSet

L inkedHashSet集合特点
	1:哈希表和链表实现的Set接口，具有可预测的迭代次序
	2:由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
	3:由哈希表保证元素唯一，也就是说没有重复的元素

6.5、 TreeSet集合概述和特点

TreeSet集合特点
1. 元素有序， 这里的顺序不是指存储和取出的顺序，而是按照-定的规则进行排序，具体排序方式取决于构造方法
	TreeSet0:根据其元素的自然排序进行排序
	TreeSet(Comparator comparator):根据指定的比较器进行排序
2. 没有带索引的方法， 所以不能使用普通for循环遍历
3. 由于是Set集合， 所以不包含重复元素的集合

import java.util.TreeSet;

public class TestTreeSet {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet<>();//默认自然排序，数据类型必须选择基本类型的包装类
        treeSet.add(50);
        treeSet.add(10);
        treeSet.add(40);
        treeSet.add(20);
        treeSet.add(30);
        treeSet.add(30);//因为实现了Set接口所以它里面的元素是不可以重复的
        
        for (Integer integer : treeSet) {
            System.out.println(integer);
        }
    }
}

6.7、自然排序Comparable的使用

1. 存储学生对象并遍历, 创建TreeSet集合使用无参构造方法
2. 要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
   结论
3. 用TreeSet集合存储自定义对象， 无参构造方法使用的是自然排序对元素进行排序的
4. 自然排序, 就是让元素所属的类实现Comparable接口， 重写compareTo(T o)方法
5. 重写方法时，一 定要注意排序规则必须按照要求的主要条件和次要条件来写

import java.util.TreeSet;

public class TestComparable {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet<>();
        treeSet.add(new Student("zhangSan",10));
        treeSet.add(new Student("liSi",15));
        treeSet.add(new Student("wangWu",14));
        treeSet.add(new Student("laoLiu",12));

        for (Student student : treeSet) {
            System.out.println(student.name+","+student.age);
            
        }
        System.out.println("----------添加后---------------");
        treeSet.add(new Student("wangWu",14));//重复的元素不会添加到集合中
        treeSet.add(new Student("bieQi",12));//年龄相同会按照字母排序
        for (Student student : treeSet) {
            System.out.println(student.name+","+student.age);
            
        }
    }
}
class Student   implements Comparable {//实现Comparable接口
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    @Override
    public int compareTo(Student o) {//实现compareTo比较方法
//        return 0;//代表重复
//        return 1;//正数升序
//        return -1;//负数降序
        int num = this.age-o.age;
        return num==0?this.name.compareTo(o.name):num;
    }
}

6.8、比较器排序Comparator的使用

1. 存储学生对象并遍历， 创建TreeSet集 合使用带参构造方法
2. 要求: 按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

//main方法里面的代码
TreeSet treeSet = new TreeSet<>(new Comparator() {//带参构造方法
    @Override
    public int compare(Student o1, Student o2) {
        int num = o1.age-o2.age;
        return num==0?o1.name.compareTo(o2.name):num;
    }
});

treeSet.add(new Student("zhangSan",10));
treeSet.add(new Student("liSi",15));
treeSet.add(new Student("wangWu",14));
treeSet.add(new Student("laoLiu",12));

for (Student student : treeSet) {
    System.out.println(student.name+","+student.age);
    
}
System.out.println("----------添加后---------------");
treeSet.add(new Student("wangWu",14));//重复的元素不会添加到集合中
treeSet.add(new Student("bieQi",12));//年龄相同会按照字母排序
for (Student student : treeSet) {
    System.out.println(student.name+","+student.age);
    
}

6.9、生成10个1~20，不重复的随机数

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;


public class SetDemo01 {
    public static void main(String[] args) {
        //Set set = new HashSet<>();//利用Set集合的不可重复性
        Set set = new TreeSet<>();//TreeSet对象可以排序

        Random random = new Random();

        while (set.size()<10){
            set.add(random.nextInt(20)+1);
        }
        for (Integer integer : set) {
            System.out.println(integer);
        }
    }
}

7、泛型 7.1、泛型概述

1. 泛型:是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编泽时检测到非法的类型它的本质是参数化类型，也就是说所操作的数据类型被指定为个参数
   一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参，那么参数化类型怎么理解呢?
   顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
   这种参数类型可以用在类，方法和按口中,分别被称为泛型类，泛型方法，泛型接口
2. 泛型定义格式:
   1. <类型>: 指定-一种类型的格式。这里的类型可以看成是形参
   2. <类型1,类型…>: 指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可以看成是形参
   3. 将来具体调用时候给定的类型可以看成是实参， 并且实参的类型只能是引用数据类型
3. 泛型的好处：
   1. 把运行时期的问题提前到编译时期
   2. 避免强制类型转换

7.2、泛型类

public class TestGenerosityClass {
    public static void main(String[] args) {
        //泛型可以让输入的参数任意化，大大提高程序的适应性
        Test stringTest = new Test<>();//定义成字符串类型
        stringTest.setArbitrarily("字符串");
        System.out.println(stringTest.getArbitrarily());

        Test integerTest = new Test<>();//定义成Integer类型
        integerTest.setArbitrarily(10);
        System.out.println(integerTest.getArbitrarily());

        Test testTest = new Test<>();//定义成他自己的类型
        testTest.setArbitrarily(new Test());
        testTest.getArbitrarily().setArbitrarily("他自己");
        System.out.println(testTest.getArbitrarily().getArbitrarily());
    }
}
//定义泛型类
class Test{
    E arbitrarily;

    public E getArbitrarily() {
        return arbitrarily;
    }

    public void setArbitrarily(E arbitrarily) {
        this.arbitrarily = arbitrarily;
    }
}

7.3、泛型方法

public class TestGenerosityMethod {
    public static void main(String[] args) {
        TestMethod testMethod = new TestMethod();
        testMethod.swh("字符串");//泛型方法,可以自适应参数
        testMethod.swh(11);
        testMethod.swh(true);
        testMethod.swh(11.0592);
    }
}
//定义泛型方法
class TestMethod{
    public  void swh(E e) {//泛型方法的定义
        System.out.println(e);
    }

}

7.4、泛型接口

泛型接口的定义格式:

• 格式: 修饰符interface接口名<类型>1 )
• 范例: public interface Generic{ )

7.5、类型通配符

为了表示各种泛型List的父类，可以使用类型通符

• 类型通配符:
• List: 表示元素类型未知的List,它的元素可以匹配任何的类型
• 这种带通配符的L ist仅表示它是各种泛型Lst的父类，并不能把元素添加到其中

如果说我们不希望List是任何泛型List的父类,只希望它代表某一类泛型List的父类, 可以使用类型通配符的上限

• 类型通配符 上限:
• List:它表示的类型是Number或者其子类型
  除了可以指定类型通配符的.上限，我们也可以指定类型通配符的下限
• 类型通配符 下限:
• List:它表示的类型是Number或者其父类型

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

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符
        List list1 = new ArrayList();
        List list2 = new ArrayList