集合

1.集合概念

对象的容器,定义了多个对象进行操作的常用方法.可实现数组的功能.

集合和数组区别

数组长度固定,集合长度不固定
数组可以存储基本类型和引用类型,集合只能存储引用类型

2.Collection父接口

Collection特点:代表一组任意类型的对象,无序、无下标、不能重复。
方法：
- boolean add(Object obj)//添加一个对象
- boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中.
- void clear()//清空此集合中的所有对象.
- boolean contains(Object o)//检查此集合中是否包含o对象
- boolean equals(Object o)//比较此集合是否与指定对象相等
- boolean isEmpty()//判断此集合是否为空
- boolean remove(Object o)//在此集合中移除o对象
- int size()//返回此集合中的元素个数
- Object toArray()//将此集合转换成数组List子接口

Collection接口的使用

package Aggregate.Collection;

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

/*
Collection接口的使用
(1)添加元素
(2)删除元素
(3)遍历元素
(4)判断
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建集合
        Collection collection = new ArrayList();
//        (1)添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        System.out.println("元素个数"+collection.size());
        System.out.println(collection.toString());
//        (2)删除元素
//        collection.remove("榴莲");
//        collection.clear();
//        System.out.println("删除之后"+collection.size());
//        (3)遍历元素
        //3.1使用增强for
        System.out.println("--3.1使用增强for--");
        for (Object object:collection) {
            System.out.println(object);
        }
        //3.2使用迭代器(迭代器专门用来遍历集合的一种方式)
        //hsaNext();有没有下一个元素
        //next();获取下一个元素
        //remove();删除当前元素
        System.out.println("--3.2使用迭代器--");
        Iterator it = collection.iterator();
        while (it.hasNext()){
            String s= (String) it.next();
            System.out.println(s);
            //不能使用collection删除方法;
            //collection.remove(s);
            //it.remove();
        }
        System.out.println("元素个数"+collection.size());
//        (4)判断
        System.out.println(collection.contains("西瓜"));
        System.out.println(collection.isEmpty());
    }
}

collection的使用:保存学生信息

package Aggregate.Collection;

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

/*
collection的使用:保存学生信息
 */
public class Demo02 {
    public static void main(String[] args) {
        //新建Collection对象
        Collection collection = new ArrayList();
        Student s1 = new Student("张三", 20);
        Student s2 = new Student("张无忌", 18);
        Student s3 = new Student("王二", 22);
        //1添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println(collection.size());
        System.out.println(collection.toString());
        //2删除
//        collection.remove(s1);
//        System.out.println("删除之后:"+collection.size());
        //3遍历
        //3.1增强for
        for (Object object:collection) {
            Student s = (Student) object;
            System.out.println(s.toString());
        }
        //3.2迭代器:hsaNext();next();remove();迭代过程中不能使用collection的删除方法
        Iterator it = collection.iterator();
        while (it.hasNext()){
            Student s  = (Student) it.next();
            System.out.println(s.toString());
        }
        //4判断
        System.out.println(collection.contains(s1));
        System.out.println(collection.isEmpty());
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.List子接口

特点:有序.、有下标、元素可以重复。
方法：
- void add(int index,Object o)//在index文职插入对象o
- boolean addAll(int index,Collection c)//将一个集合中的元素添加到此集合中的index位置
- Object get(int index)//返回集合中指定位置的元素
- List subList(int fromIndex,int toIndex)//返回fromIndex和toIndex之间的集合元素(含头不含尾)

List子接口

package Aggregate.List;

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

/*
List子接口的特点
特点:1.有序、有下标，2.可以重复
 */
public class Demo01 {
    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.toString());
        //2删除元素
//        list.remove("苹果");
//        list.remove(0);
//        System.out.println("删除之后："+list.size());
//        System.out.println(list.toString());
        //3遍历元素
        //3.1使用for遍历
        System.out.println("--3.1使用for遍历--");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //3.2使用增强for
        System.out.println("--3.2使用增强for--");
        for (Object o : list) {
            System.out.println(o);
        }
        //3.3使用迭代器
        Iterator it = list.iterator();
        System.out.println("--3.3使用迭代器--");
        while (it.hasNext()){
            System.out.print(it.next());
        }
        //3.4使用列表迭代器，和Iterator的区别，ListIterator可以向前或向后遍历、添加、删除、修改元素
        ListIterator lit = list.listIterator();
        System.out.println("--3.4使用列表迭代器从前往后--");
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        System.out.println("--3.4使用列表迭代器从后往前--");
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
        //4判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());
        //5获取位置
        System.out.println(list.indexOf("华为"));
    }
}

List的使用

package Aggregate.List;

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

/*
List的使用
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();
        //添加数字数据
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());
        //2删除操作
        //list.remove(0);
        list.remove((Object)20);
        System.out.println("删除之后:"+list.size());
        System.out.println(list.toString());

        //3补充方法sublist：返回了集合,含头不含尾
        List sublist = list.subList(1, 3);
        System.out.println(sublist.toString());
    }
}

List实现类

ArrayList[重点]:
- 数组结构实现,查询快、增删慢；
- JDK1.2版本，运行效率快、线程不安全。
- 源码分析：DEFAUT_CAPACITY=10;默认容量,注意：如果没有向集合中添加任何元素，容量是0,添加一个元素之后容量就是10了；每次扩容大小大欧式原来的1.5倍
  
  elementData;存放元素的数组
  
  size；实际元素个数
  
  add();添加元素
Vector：
- 数组结构实现，查询快、增删慢；
- JDK1.0版本，运行效率慢、线程安全。
LinkedList：
- 链表结构实现，增删块，查询慢。

ArrayList的使用

package Aggregate.List;

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

/*
ArrayList的使用
存储结构：数组，查找遍历速度快，增删慢
 */
public class arrayList {
    public static void main(String[] args) {
        //创建集合
        ArrayList arrayList = new ArrayList<>();
        //1添加元素
        Student s1 = new Student("刘德华",20);
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数:"+arrayList.size());
        System.out.println(arrayList.toString());
        //2删除元素
//        arrayList.remove(s1);
//        arrayList.remove(new Student("刘德华",20));//equals(this==ob)
//        System.out.println("删除之后："+arrayList.size());

        //3遍历元素【重点】
        //3.1使用迭代器
        System.out.println("--3.1使用迭代器--");
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }

        //3.2列表迭代器
        ListIterator lit = arrayList.listIterator();
        System.out.println("--3.2使用列表迭代器正序--");
        while (lit.hasNext()){
            Student s = (Student) lit.next();
            System.out.println(s.toString());
        }
        System.out.println("--3.2使用列表迭代器逆序--");
        while (lit.hasPrevious()){
            Student s = (Student) lit.previous();
            System.out.println(s.toString());
        }

        //4判断
        System.out.println(new Student("梁朝伟",18));//对Student进行了重写,就可以通过这种方式删除
        System.out.println(arrayList.isEmpty());

        //5查找
        System.out.println(arrayList.indexOf(new Student("梁朝伟",18)));
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
        @Override
    public boolean equals(Object obj) {
        //1判断是不是同一个对象
        if (this==obj){
            return true;
        }
        //2判断是否为空
        if (obj==null){
            return false;
        }
        //3判断是否是Student类型
        if (obj instanceof Student){
            Student s = (Student) obj;
            //4比较属性
            if ((this.name.equals(s.getName())&&this.age==s.getAge())){
                return true;
            }
        }
        //5不满足条件返回false
        return false;
    }
}

Vector的使用

package Aggregate.List;

import java.util.Enumeration;
import java.util.Vector;

/*
演示Vector集合的使用
存储结构：数组
 */
public class vector {
    public static void main(String[] args) {
        //创建几个
        Vector vector = new Vector<>();
        //1添加元素
        vector.add("草莓");
        vector.add("芒果");
        vector.add("西瓜");
        System.out.println("元素个数："+vector.size());

        //2删除
//        vector.remove(0);
//        vector.remove("西瓜");
//        vector.clear();

        //3遍历
        //使用枚举器
        Enumeration en = vector.elements();
        while (en.hasMoreElements()){
            String o = (String) en.nextElement();
            System.out.println(o);
        }

        //4判断
        System.out.println(vector.contains("西瓜"));
        System.out.println(vector.isEmpty());

        //5Vector其他方法
        //firsetElement、lastElement、element();
    }
}

LinkedList的使用

package Aggregate.List;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

/*
LinkedList的使用
存储结构：双向链表
 */
public class linkedList {
    public static void main(String[] args) {
        //创建集合
        LinkedList linkedList= new LinkedList();
        //1添加元素
        Student s1 = new Student("刘德华",20);
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println("元素个数："+linkedList.size());
        System.out.println(linkedList.toString());
        //2删除
//        linkedList.remove(new Student("刘德华",20));
//        System.out.println("删除之后："+linkedList.toString());
//        linkedList.clear();

        //3遍历
        //3.1for遍历
        System.out.println("--3.1for遍历--");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        //3.2增强for
        System.out.println("--3.2增强for--");
        for (Object o : linkedList) {
            Student s = (Student)o;
            System.out.println(o);
        }
        //3.3使用迭代器
        Iterator it = linkedList.iterator();
        System.out.println("--3.3使用迭代器--");
        while (it.hasNext()){
            Student s= (Student) it.next();
            System.out.println(s.toString());
        }
        //3.4使用列表迭代器
        System.out.println("--3.4使用列表迭代器--");
        ListIterator lit = linkedList.listIterator();
        while (lit.hasNext()){
            Student s= (Student) lit.next();
            System.out.println(s.toString());
        }

        //4判断
        System.out.println(linkedList.contains(s1));
        System.out.println(linkedList.isEmpty());

        //5获取
        System.out.println(linkedList.indexOf(s2));
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
        @Override
    public boolean equals(Object obj) {
        //1判断是不是同一个对象
        if (this==obj){
            return true;
        }
        //2判断是否为空
        if (obj==null){
            return false;
        }
        //3判断是否是Student类型
        if (obj instanceof Student){
            Student s = (Student) obj;
            //4比较属性
            if ((this.name.equals(s.getName())&&this.age==s.getAge())){
                return true;
            }
        }
        //5不满足条件返回false
        return false;
    }
}

泛型

Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
常见形式有泛型类、泛型接口、泛型方法。
语法：<T,....>T称为类型占位符，表示一种引用类型。
好处：
- 提高代码的重用性
- 防止类型转换异常，提高代码的安全性

泛型类

package Aggregate.MyGeneric;
/*
泛型类
语法：类名<T>
T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
 */
public class Demo01<T>{
    //使用泛型T
    //1创建变量
    T t;

    //2泛型作为方法的参数
    public  void show(T t){
        //不能直接new对象(实例化)
        System.out.println(t);
    }
    //3使用泛型作为方法的返回值
    public  T getT(){
        return t;
    }
}

泛型接口

package Aggregate.MyGeneric;
/*
泛型接口
语法:接口名<T>
注意:不能泛型静态常量
 */
public interface interface01<T> {
    String name = "张三";

    T server(T t);
}

实现接口

两种方法:

1.在实现接口的时候确定泛型类

package Aggregate.MyGeneric;

public class InterfaceImpl implements interface01<String> {

    @Override
    public String server(String t) {
        System.out.println(t);
        return t;
    }
}

2.实现类也是一个泛型,在使用时确定泛型类

package Aggregate.MyGeneric;

public class Interface02<T> implements interface01<T>{

    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

泛型方法

package Aggregate.MyGeneric;
/*
泛型方法
语法:<T>返回值类型
 */
public class Method {
    //泛型方法
    public <T> T  show(T t){
        System.out.println("泛型方法:"+t);
        return t;
    }
}

泛型测试类

package Aggregate.MyGeneric;

public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象
        //注意:1泛型只能使用引用类型,2不同泛型类型对象之间不能相互赋值
        Demo01<String> demo01 = new Demo01<String>();
        //1.创建变量
        demo01.t="hello";
        System.out.println(demo01.t);
        //2泛型作为方法的参数
        demo01.show("大家好，加油");
        //3使用泛型作为方法返回值
        String string = demo01.getT();

        Demo01<Integer> demo012= new Demo01<>();
        demo012.t=100;
        demo012.show(200);
        Integer integer = demo012.getT();
		//泛型接口
        //泛型接口1
        InterfaceImpl impl = new InterfaceImpl();
        impl.server("xxxx");
		//泛型接口2
        Interface02<Integer> impl2 = new Interface02<>();
        impl2.server(2000);

        //泛型方法
        Method method = new Method();
        method.show("中国加油");
        method.show(200);
        method.show(3.14);
    }
}

泛型集合

概念:参数化类型、类型安全的集合，强制集合元素的类型必须一致。
特点：
- 编译时即可检查，而非运行时抛出异常。
- 访问时，不必类型转换（拆箱）。
- 不同泛型之间引用不能相互赋值，泛型不存在多态。

package Aggregate.MyGeneric;

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

public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("xxx");
        arrayList.add("yyy");
//        arrayList.add(10);
//        arrayList.add(20);
        for (String string : arrayList) {
            System.out.println(string);
        }
        ArrayList<Student> arrayList2 = new ArrayList<Student>();
        Student s1 = new Student("刘德华",20);
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        arrayList2.add(s1);
        arrayList2.add(s2);
        arrayList2.add(s3);
        Iterator<Student> it = arrayList2.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.toString());
        }
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
        @Override
    public boolean equals(Object obj) {
        //1判断是不是同一个对象
        if (this==obj){
            return true;
        }
        //2判断是否为空
        if (obj==null){
            return false;
        }
        //3判断是否是Student类型
        if (obj instanceof Student){
            Student s = (Student) obj;
            //4比较属性
            if ((this.name.equals(s.getName())&&this.age==s.getAge())){
                return true;
            }
        }
        //5不满足条件返回false
        return false;
    }
}

通配符

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

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

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

类型通配符上限:<? extends 类型>
List <? extends Number>:它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限,我们也可以指定类型通配符的下限

类型通配符下限:<? super 类型>
List<? supr Number>:它表示的类型是Number或者其父类型

package Aggregate.MyGeneric;

import com.sun.org.apache.xerces.internal.xs.datatypes.ObjectList;

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

/*
    类型通配符<?>
        list<?>,表示元素类型未知的list,它的元素可以匹配任何的类型
        这种带通配符的List仅表示它是各种类型list的父类,并不能把元素添加到其中

    类型通配符上限,<? extends 类型>
        list<? extends Number>:它表示的类型是Number或者其子类型

    类型通配符下限,<? super 类型>
        list<? super Number>:它表示的类型是Number或者其父类型
*/
public class GenericWildcard {
    public static void main(String[] args) {
        //类型通配符:<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("--------");
        //类型通配符上限,<? extends 类型>
//        List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();

        //类型通配符下限:<? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
//        List<? super Number> list9 = new ArrayList<Integer>();


    }
}

可变参数

可变参数又称参数个数可变,作用方法的形参出现,那么方法参数个数就是可变的了

格式:修饰符返回值类型方法名(数据类型... 变量名){}
范例:public static int sum(int... a){}

可变参数注意事项

这里的变量其实是一个数组
如果一个方法有多个参数,包含可变参数,可变参数要放在最后

package Aggregate.MyGeneric;

public class ArgsDemo01 {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
       System.out.println(sum(10,20,30,40));
        //可变参数的输出
        System.out.println(sum(10,20,30,40,50));
        System.out.println(sum(10,20,30,40,50,60));
        System.out.println(sum(10,20,30,40,50,60,70));
    }
    /*
    public static int sum (int b,int... a){}//注意:一个方法有多个参数,且包含可变参数,可变参数要放在最后.
     */
    public static int sum(int... a){
//        System.out.println(a);
//        return 0;
        int sum = 0;
        for (int i: a) {
            sum+=1;
        }
        return sum;
    }
    
    public static int sum(int a,int b){
        return a+b;
    }
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
    public static int sum(int a,int b,int c,int d){
        return a+b+c+d;
    }
}

可变参数的使用

Arrays工具类中有一个静态方法:
- public static <T> List<T> asList(T... a):返回有指定数组支持的固定大小的列表
- 返回的集合不能做增删操作,可以做修改操作
List接口中有一个静态方法:
- public static <E> List<E> of(E... elements):返回包含任意数量元素的不可变列表
- 返回的集合不能做增删改操作
- 注意:jdk1.8没有这个特性
Set接口中有一个静态方法:
- public static<E> Set<E> of(E... elements):返回一个包含任意数量元素的不可变集合
- 在给元素的时候,不能给重复的元素
- 返回的集合不能做增删操作,没有修改的方法

Set集合

Set子接口

特点:无序、无下标、元素不可重复
方法：全部继承自Collection中的方法

package Aggregate.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*
测试Set接口的使用
特点:1.无序、没有下标。2.不能重复。
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();
        //1添加数据
        set.add("苹果");
        set.add("华为");
        set.add("小米");
        System.out.println("数据个数"+set.size());
        System.out.println(set.toString());
        //2删除
        set.remove("小米");
        System.out.println(set.toString());
        //3遍历[重点]
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (String string : set) {
            System.out.println(string);
        }
        //3.2迭代器
        System.out.println("----3.2迭代器----");
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println("华为");
        System.out.println(set.isEmpty());
    }
}

Set实现类

HashSet[重点]:
- 基于HashCode计算元素存放位置
- 当存入元素的哈希码相同时,会调用equals进行确认,如结果为true,则拒绝后者存入
TreeSet
- 基于排列顺序实现元素不重复
- 实现了SortedSet接口,对集合元素自动排序
- 元素对象的类型必须实现Compareable接口,指定排序规则
- 通过CompareTo方法确定是否为重复元素

HashSet的简单使用

package Aggregate.set;

import java.util.HashSet;
import java.util.Iterator;

/*
HashSet集合的使用
存储结构:哈希表(数组+链表+红黑树(jdk1.8后))
 */
public class Demo02 {
    public static void main(String[] args) {
        //新建集合
        HashSet<String> hashSet = new HashSet<>();
        //1添加元素
        hashSet.add("刘德华");
        hashSet.add("梁朝伟");
        hashSet.add("林志玲");
        hashSet.add("周润发");
        //hashSet.add("刘德华");
        System.out.println("元素个数:"+hashSet.size());
        System.out.println(hashSet.toString());
        //2删除数据
        hashSet.remove("刘德华");
        System.out.println("删除之后:"+hashSet.size());
        //3遍历操作
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (String string : hashSet) {
            System.out.println(string);
        }
        //3.2使用迭代器
        System.out.println("----3.2迭代器----");
        Iterator<String> it = hashSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(hashSet.contains("郭富城"));
        System.out.println(hashSet.isEmpty());
    }
}

HashSet"进阶版"

package Aggregate.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;

/*
HashSet的使用
存储结构:哈希表(数组+链表+红黑树(jdk1.8后))
存储过程
(1)根据华顺从的,计算保存的位置,如果此位置为空,则直接保存;如果不为空,执行第二步
(2)可执行equals方法,如果equals方法为true,则认为是重复,否则,形成链表
 */
public class Demo03 {
    public static void main(String[] args) {
        //创建集合
        HashSet<Person> persons = new HashSet<>();
        //1添加数据
        Person p1 = new Person("刘德华",20);
        Person p2 = new Person("林志玲",22);
        Person p3 = new Person("梁朝伟",25);

        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(new Person("梁朝伟",25));//当重写hashCode和equals此处就添加不进去了.

        System.out.println("元素个数:"+persons.size());
        System.out.println(persons.toString());

        //2删除操作
        persons.remove(p1);
        System.out.println("删除之后:"+persons.size());
        //3遍历
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (Person person : persons) {
            System.out.println(person.toString());
        }
        //3.2迭代器
        System.out.println("----3.2迭代器----");
        Iterator<Person> it =persons.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(persons.contains(p1));
        System.out.println(persons.contains(new Person("林志玲",22)));
        System.out.println(persons.isEmpty());
    }
}

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 +
                '}';
    }
//重写hashCode和equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

TreeSet的简单使用

package Aggregate.set;

import java.util.Iterator;
import java.util.TreeSet;

/*
TreeSet的使用
存储结构:红黑树
 */
public class Demo04 {
    public static void main(String[] args) {
        //1创建集合
        TreeSet<String> treeSet = new TreeSet<>();
        //1添加元素
        treeSet.add("xyz");
        treeSet.add("abc");
        treeSet.add("hello");
//        treeSet.add("xyz");
        System.out.println("元素个数:"+treeSet.size());
        System.out.println(treeSet.toString());

        //2删除
        treeSet.remove("xyz");
        System.out.println("删除之后:"+treeSet.size());
        System.out.println(treeSet.toString());

        //3遍历
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (String string : treeSet) {
            System.out.println(string);
        }
        //3.2迭代器
        System.out.println("----3.2迭代器----");
        Iterator<String> it = treeSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(treeSet.ceiling("abc"));
    }
}

TreeSet的"进阶版"

package Aggregate.set;

import java.util.Iterator;
import java.util.TreeSet;
import java.util.Objects;

/*
TreeSet的使用
存储结构:红黑树
要求:元素必须要实现Comparable接口,在自定义比较规则;comparaTo()方法返回值为0,认为是重复元素
 */
public class Demo05 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Person> persons = new TreeSet<>();
        //1添加元素
        Person p1 = new Person("xyz",20);
        Person p2 = new Person("hello",22);
        Person p3 = new Person("zhangsan",25);
        Person p4 = new Person("zhangsan",20);

        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);
        System.out.println("元素个数:"+persons.size());
        System.out.println(persons.toString());
        //2删除
//        persons.remove(p1);
//        System.out.println("删除之后:"+persons.size());
        //3遍历
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (Person person : persons) {
            System.out.println(person);
        }
        //3.2迭代器
        System.out.println("----3.2迭代器----");
        Iterator<Person> it = persons.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(persons.contains(new Person("zhangsan",20)));
    }
}
class Person  implements Comparable<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 +
                '}';
    }
    //重写hashCode和equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    //先按姓名比,然后在按年龄比
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 =this.age-o.getAge();

        return n1==0?n2:n1;
    }
}

Comparator接口

package Aggregate.set;

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

/*
TreeSet集合的使用
Comparator:实现定制比较(比较器)
 */
public class Demo06 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {
            //创建集合,并指定比较规则
            @Override
            public int compare(Person o1, Person o2) {
                int n1=o1.getAge()-o2.getAge();
                int n2 = o1.getName().compareTo(o2.getName());

                return n1==0?n2:n1;
            }
        });
        //1添加元素
        Person p1 = new Person("xyz",20);
        Person p2 = new Person("hello",22);
        Person p3 = new Person("zhangsan",25);

        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        System.out.println(persons.toString());
    }

}

Comparator接口"进阶版"

	package Aggregate.set;

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

/*
要求:使用TreeSet集合实践字符串按照长度进行排序
helloworld zhang lisi wangwu beijing xian nanjing
Comparator接口实现定制比较
 */
public class Demo07 {
    public static void main(String[] args) {
        //创建集合,并指定规则
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 =o1.length()-o2.length();
                int n2 = o1.compareTo(o2);
                return n1==0?n2:n1;
            }
        });
        //添加数据
        treeSet.add("helloworld");
        treeSet.add("pingguo");
        treeSet.add("lisi");
        treeSet.add("zhnagsan");
        treeSet.add("beijing");
        treeSet.add("cat");
        treeSet.add("nanjing");
        treeSet.add("xian");
        System.out.println(treeSet);
    }
}

Map集合

Map接口

特点:用于存储任意键值对(Ket-Value),无序、无下标，键不可重复，值可重复
方法：
- V put(K key,V value)//将对象存入到集合中,关联键值.key重复则覆盖原值.
- Object get(Object key)//根据键获取对应的值
- Set<K> keySet() //返回所有key
- Collection<V> values() //返回包含所有值得Collection集合.

package Aggregate.map;

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

/**
 * Map接口的使用
 * 特点:(1)存储键值对(2)键不能重复,值可重复(3)无序
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>();
        //1添加元素
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");

        System.out.println("元素个数:"+map.size());
        System.out.println(map.toString());

        //2删除
//        map.remove("usa");//通过删除key来达到删除目的
//        System.out.println("删除过后:"+map.size());

        //3遍历
        //3.1使用keySet();
        System.out.println("--keySet--");
        Set<String> keyset= map.keySet();//如果把for循环里面的keyset换成,map.keyset就可以把这个省略
        for (String key : keyset) {
            System.out.println(key+"----"+map.get(key));
        }
        //3.2使用entrySet()方法
        System.out.println("--entrySet--");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }

        //4判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));

    }
}

Map集合的实现类

HashMap[重点]

JDK1.2版本,线程不安全,运行效率快;允许用null作为key或是value

Hashtable:

JDK1.0版本,线程安全,运行效率慢;不允许null作为key或是value

Properties

Hashtable的子类,要求key和value都是String.通常用于配置文件的读取.

TreeMap

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

总结:

(1)HashMap刚创建是,table是null,为了节省空间,当添加第一个元素时,table容量调为16
(2)当元素个数大于阈值(16*0.75=12)时,会进行扩容,扩容后大小为原来的2倍.目的是减少调整元素的个数
(3)jdk1.8,当每个链表长度大于8,并且数组元素个数大于等于64时,会调整红黑树,目的是提高执行效率
(4)jdk1.8,当链表长度小于6时,调整成链表
(5)jdk1.8以前,链表时头插入,jdk1.8以后是尾插入

Map接口的使用

package Aggregate.map;

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

/**
 * Map接口的使用
 * 特点:(1)存储键值对(2)键不能重复,值可重复(3)无序
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>();
        //1添加元素
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");

        System.out.println("元素个数:"+map.size());
        System.out.println(map.toString());

        //2删除
//        map.remove("usa");//通过删除key来达到删除目的
//        System.out.println("删除过后:"+map.size());

        //3遍历
        //3.1使用keySet();
        System.out.println("--keySet--");
        Set<String> keyset= map.keySet();//如果把for循环里面的keyset换成,map.keyset就可以把这个省略
        for (String key : keyset) {
            System.out.println(key+"----"+map.get(key));
        }
        //3.2使用entrySet()方法
        System.out.println("--entrySet--");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }

        //4判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));

    }
}

HashMap集合的使用

package Aggregate.map;

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

/*
HashMap集合的使用
存储结构:哈希表(数组+链表+红黑树)
使用key可hashCode和equals作为重复
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建集合
        HashMap<Studnt,String> studets = new HashMap<Studnt,String>();
        //1添加元素
        Studnt s1 = new Studnt("孙悟空",100);
        Studnt s2 = new Studnt("猪八戒",101);
        Studnt s3 = new Studnt("沙和尚",102);
        studets.put(s1,"北京");
        studets.put(s2,"上海");
        studets.put(s3,"杭州");
        studets.put(new Studnt("沙和尚",102),"杭州");
        System.out.println("元素个数:"+studets.size());
        System.out.println(studets.toString());
        //2删除元素
        studets.remove(s1);
        System.out.println("删除之后:"+studets.size());
        //3遍历
        //3.1使用keyset();
        System.out.println("--keyset--");
        for (Studnt key: studets.keySet()) {
            System.out.println(key.toString()+"==="+studets.get(key));
        };
        //3.2使用entrySet();
        System.out.println("--entrySet--");
        for (Map.Entry<Studnt,String> entry: studets.entrySet()) {
            System.out.println(entry.getKey()+"--"+entry.getKey());
        }
        //4判断
        System.out.println(studets.containsKey(s1));
        System.out.println(studets.containsValue("杭州"));
    }
}
class Studnt{
    private String name;
    private int stuNO;

    public Studnt() {
    }

    public Studnt(String name, int stuNO) {
        this.name = name;
        this.stuNO = stuNO;
    }

    public String getName() {
        return name;
    }

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

    public int getStuNO() {
        return stuNO;
    }

    public void setStuNO(int stuNO) {
        this.stuNO = stuNO;
    }

    @Override
    public String toString() {
        return "Studnt{" +
                "name='" + name + '\'' +
                ", stuNO=" + stuNO +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Studnt studnt = (Studnt) o;
        return stuNO == studnt.stuNO &&
                name.equals(studnt.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, stuNO);
    }
}

TreeMap的使用

package Aggregate.map;

import java.util.Map;
import java.util.TreeMap;
import java.util.Objects;

/*
TreeMap的使用
存储结构:红黑树
 */
public class Demo03 {
    public static void main(String[] args) {
        //新建集合
        TreeMap<Studnt,String> treeMap = new TreeMap<Studnt,String>();
        //1添加元素
        Studnt s1 = new Studnt("孙悟空",100);
        Studnt s2 = new Studnt("猪八戒",101);
        Studnt s3 = new Studnt("沙和尚",102);
        treeMap.put(s1,"北京");
        treeMap.put(s2,"上海");
        treeMap.put(s3,"南京");
        System.out.println("元素个数:"+treeMap.size());
        System.out.println(treeMap.toString());
        //2删除
        treeMap.remove(s3);
        System.out.println("删除之后:"+treeMap.toString());
        //3遍历
        //3.1使用keyset();
        System.out.println("--keyset--");
        for (Studnt key: treeMap.keySet()) {
            System.out.println(key+"---"+treeMap.get(key));
        }
        //3.2使用entryset();
        System.out.println("--entryset--");
       for (Map.Entry<Studnt,String> entry: treeMap.entrySet()){
           System.out.println(entry.getKey()+"----"+entry.getValue());
       }
       //4判断
        System.out.println(new Studnt("沙和尚",102));

    }
}

class Studnt implements Comparable<Studnt>{
    private String name;
    private int stuNO;

    public Studnt() {
    }

    public Studnt(String name, int stuNO) {
        this.name = name;
        this.stuNO = stuNO;
    }

    public String getName() {
        return name;
    }

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

    public int getStuNO() {
        return stuNO;
    }

    public void setStuNO(int stuNO) {
        this.stuNO = stuNO;
    }

    @Override
    public String toString() {
        return "Studnt{" +
                "name='" + name + '\'' +
                ", stuNO=" + stuNO +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Studnt studnt = (Studnt) o;
        return stuNO == studnt.stuNO &&
                name.equals(studnt.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, stuNO);
    }


    @Override
    public int compareTo(Studnt o) {
        int n1 =this.name.compareTo(o.getName());
        int n2 =this.stuNO-o.getStuNO();
        return n2;
    }
}

Collections工具类

概念:集合工具类,定义除了存取以外的集合常用方法
方法:
- public static void reverse(List<?> list)//反转集合中元素的排序
- public static void shuffle(List<?> kist)//随机重置集合元素的顺序
- public static void sort(LIst<?> list)//升序排序(元素类型必须实现Comparable接口)

package Aggregate.map;

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

/*
演示Collections工具类的使用
 */
public class Demo04 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(5);
        list.add(12);
        list.add(30);
        list.add(6);
        //sort排序
        System.out.println("排序之前:"+list.toString());
        Collections.sort(list);
        System.out.println("排序之后:"+list.toString());
        //binarySearch二分查找
        int i = Collections.binarySearch(list,13);
        System.out.println(i);
        //copy
        List<Integer> dest =new ArrayList<>();
        for (int j = 0; j < list.size(); j++) {
            dest.add(0);
        }
        Collections.copy(dest,list);
        System.out.println(dest.toString());
        //reverse反转
        Collections.reverse(list);
        System.out.println("反转之后:"+list.toString());
        //shuffle 打乱
        Collections.shuffle(list);
        System.out.println("打乱之后:"+list.toString());

        //补充,list转成数组
        System.out.println("--list转成数组--");
        Integer[] arr = list.toArray(new Integer[0]);
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));

        //数组转成集合
        System.out.println("--数组转成集合--");
        String[] names = {"张三","李四","王五"};
        //集合是一个受限集合,不能添加和删除
        List<String> list1 = Arrays.asList(names);

        System.out.println(list1);

        //把基本类型数组转成集合,需要修改为包装类
        Integer[] nums = {100,200,300,400,500};
        List<Integer> list2 = Arrays.asList(nums);
        System.out.println(list2);
    }
}