标签：System println add Student 集合 new out

集合

集合概念：

对象的容器，实现了对对象常用的操作，类似数组功能

和数组的区别：

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

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()//将此集合转换成数组
- Iterator iterator()//返回此collection的元素上进行迭代的迭代器实现遍历
- boolean removeAll(Object o )// 去除两个集合的交集
- boolean retainAll(Object o)//保留两个集合的交集

Collection接口的使用：String

package OOP.collection;

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

/**
 * @version: java version 1.8
 * @Author: 14
 *  * Collection接口的使用
 *  * 1、添加
 *  * 2、删除
 *  * 3、遍历
 *  * 4、判断
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        Collection collection = new ArrayList();
//         *  * 1、添加
        collection.add(1);
        collection.add(2);
        collection.add(3);
        System.out.println("元素个数：" + collection.size());
        System.out.println(collection);
//         *  * 2、删除
        //collection.remove(2);
        //collection.clear();
        //System.out.println("删除后个数：" + collection.size());
//         *  * 3、遍历(重点)
        //3.1 增强for
        for (Object o : collection) {
            System.out.println(o);
        }
        //3.2 迭代器(专门用来遍历集合的方式)
        //hasNext()有没有下一个元素
        //next()获取下一个元素
        //remove()删除当前元素
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
            //不能使用collection删除方法
            //collection.remove(iterator.next())  ×
            //iterator.remove(); √
        }
        System.out.println(collection.size());
//         *  * 4、判断
        System.out.println(collection.contains(1));
        System.out.println(collection.isEmpty());
    }
}

Collection接口的使用:保存学生信息（对象）

package OOP.collection;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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 +
                '}';
    }
    //下方ArrayList示例时重写，本例时没重写该方法
    @Override
    public boolean equals(Object obj) {
        //是不是同一个对象
        if (this == obj) return true;
        //是不是为空
        if (obj == null) return false;
        //是不是Student类型
        if (obj instanceof Student) {
            Student student = (Student) obj;
            //比较属性
            if (this.name.equals(student.getName()) && this.age == student.getAge()) {
                return true;
            }
        }
        //不满足条件 false
        return false;
    }
}

package OOP.collection;

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

/**
 * @version: java version 1.8
 * @Author: 14
 *  * Collection接口的使用:保存学生信息
 */
public class Demo {
    public static void main(String[] args) {
        //新建Collection对象
        Collection collection = new ArrayList();
        Student s1 = new Student(18,"Smith");
        Student s2 = new Student(19,"John");
        Student s3 = new Student(20,"Mike");
        //1.添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println(collection.size());
        System.out.println(collection.toString());
        //2.删除
        //只是删除了 collection里存储的这个对象的地址
        collection.remove(s1);
        //3.遍历
        //3.1 增强for
        for (Object o : collection) {
            Student s = (Student) o;
            System.out.println(s.toString());
        }
        System.out.println("=====================");
        //3.2 迭代器:hasNext(),next(),remove();  迭代过程中不能使用collection的删除方法
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            Student s = (Student) iterator.next();
            System.out.println(s.toString());
        }
        //4.判断  collection里存的是学生对象的地址 所以无法查询是否包含的具体内容
        System.out.println(collection.contains("Smith"));
        System.out.println(collection.contains(s2));
    }
}

List子接口

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

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @Author: 14
 *  * List接口的使用:
 *    有序、有下标、可重复
 */
public class Demo {
    public static void main(String[] args) {
        //新建List对象
        List list = new ArrayList();
        //添加
        list.add("A");
        list.add("B");
        list.add(0,"C");
        System.out.println("元素个数：" + list.size());
        System.out.println(list.toString());
        //删除
//        list.remove("B");
//        list.remove(0);
//        System.out.println("元素个数：" + list.size());
        //遍历
        //for
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //增强for
        for (Object o : list) {
            System.out.println(o.toString());
        }
        //迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //列表迭代器,和Iterator的区别：ListIterator 可以向前或向后遍历、添加、删除、修改元素
        ListIterator listIterator = list.listIterator();
        System.out.println("--------从前往后---------");
        while (listIterator.hasNext()) {
            System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }
        System.out.println("--------从后往前---------");
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
        }
        //判断
        System.out.println(list.contains("B"));
        System.out.println(list.isEmpty());
        //获取位置
        System.out.println(list.indexOf("C"));
    }
}

List实现类

ArrayList（重点）：

数组结构实现，查询快、增删慢；
JDK1.2版本，运行效率快、线程不安全

源码分析：

默认容量：DEFAULT_CAPACITY = 10
- 如果没有向集合中添加任何元素，容量为0，size为0，除了第一次扩容容量为10，后面每次扩容容量为原来的1.5倍
存放元素的数组：elementData
实际元素个数：size

add()：添加元素

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
->
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
->
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
->
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
->
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

Vector：
- 数组结构实现，查询快、增删慢；
- JDK1.0版本，运行效率慢、线程安全
LinkedList：
- 链表结构实现，增删快、查询慢

ArrayList

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @Author: 14
 * ArrayList的使用:
 */
public class Demo {
    public static void main(String[] args) {
        //新建集合
        ArrayList arrayList = new ArrayList();
        //增
        Student s1 = new Student(30, "Andy");
        Student s2 = new Student(30, "Chris");
        Student s3 = new Student(30, "Luise");
        arrayList.add(s1);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数"+arrayList.size());
        System.out.println(arrayList.toString());
        //删
//        arrayList.remove(s1);
//        //重写Student的equals方法后能够使用下面这一句删除对象
//        arrayList.remove(new Student(30,"Andy"));
//        System.out.println("元素个数"+arrayList.size());
        //遍历（重点）
        //3.1 迭代器
        System.out.println("--------迭代器----------");
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Student student = (Student) iterator.next();
            System.out.println(student.toString());
        }
        //3.2 列表迭代器
        System.out.println("--------列表迭代器 正序----------");
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()) {
            Student student = (Student) listIterator.next();
            System.out.println(student.toString());
        }
        System.out.println("--------列表迭代器 逆序----------");
        while (listIterator.hasPrevious()) {
            Student student = (Student) listIterator.previous();
            System.out.println(student.toString());
        }
        //判断
        //重写Student的equals方法后能够使用new
        System.out.println(arrayList.contains(new Student(30, "Luise")));
        System.out.println(arrayList.isEmpty());
        //查找
        //重写Student的equals方法后能够使用new
        System.out.println(arrayList.indexOf(new Student(30, "Luise")));
    }
}

Vector

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @Author: 14
 * Vector的使用:
 */
public class Demo {
    public static void main(String[] args) {
        //新建集合
        Vector v = new Vector();
        //增
        v.add("西瓜");
        v.add("香蕉");
        v.add("菠萝");
        //删
//        v.remove(0);
//        v.remove("西瓜");
//        v.clear();
        //遍历
        //使用枚举器
        Enumeration elements = v.elements();
        while (elements.hasMoreElements()) {
            String s = (String) elements.nextElement();
            System.out.println(s);
        }
        //判断
        System.out.println(v.contains("西瓜"));
        System.out.println(v.isEmpty());
        //其他方法
        //firstElement,lastElement,ElementAt();
    }
}

LinkedList

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @Author: 14
 * LinkedList接口的使用:
 * 存储结构：双向链表
 */
public class Demo {
    public static void main(String[] args) {
        //新建集合
        LinkedList list = new LinkedList<>();
        //增
        Student s1 = new Student(30, "Andy");
        Student s2 = new Student(30, "Chris");
        Student s3 = new Student(30, "Luise");
        list.add(s1);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        System.out.println("元素个数"+list.size());
        System.out.println(list);
        //删
//        list.remove(0);
//        list.remove(new Student(30, "Andy"));
//        list.clear();
        //遍历
        //for
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //增强for
        for (Object o : list) {
            System.out.println(o);
        }
        //迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //ListIterator
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        //判断
        System.out.println(list.contains(s1));
        System.out.println(list.isEmpty());

        //查找
        System.out.println(list.indexOf(s1));
    }
}

ArrayList和LinkedList的区别

不同实现结构：

泛型

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

泛型类

package OOP.collection;

/**
 * @version: java version 1.8
 * @Author: 14
 * 泛型类
 * 语法：类名<T>
 *     T表示一种引用类型，如编写多个，用逗号隔开
 */
public class MyGeneric<T>{
    //使用泛型T
    //1 创建变量
    T t;
    //2 添加方法
    public void show(T t){
        System.out.println(t);
    }
    //3 泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

泛型接口

package OOP.collection;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class MyInterfaceImpl implements MyInterface<String> {

    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}
package OOP.collection;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class MyInterfaceImpl2<T> implements MyInterface<T> {
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

泛型方法

package OOP.collection;

/**
 * @version: java version 1.8
 * @Author: 14
 * 泛型方法
 * 语法：<T> 返回值类型
 */
public class MyGenericMethod {
    //泛型方法
    public <T> void method(T t) {
        System.out.println("泛型方法" + t );
    }
}

使用

package OOP.collection;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象
        //注意：1、泛型只能使用引用类型 2、不同泛型类型对象之间不能相互赋值
        MyGeneric<Integer> myGeneric = new MyGeneric<>();
        myGeneric.t = 100;
        myGeneric.show(10000);
        Integer i = myGeneric.getT();

        //泛型接口
        MyInterfaceImpl myInterfaceImpl = new MyInterfaceImpl();
        myInterfaceImpl.server("sss");
        MyInterfaceImpl2 myInterfaceImpl2 = new MyInterfaceImpl2();
        myInterfaceImpl2.server(1000);

        //泛型方法
        MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.method("Smith");
        myGenericMethod.method(200);
    }
}

泛型集合

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

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @Author: 14
 * 泛型集合应用
 */
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
//      添加的数据与规定的泛型不一致，不能添加
//        list.add(111);
//        list.add(222);
        ArrayList<Student> studentArrayList = new ArrayList<Student>();
        Student s1 = new Student(19, "aa");
        Student s2 = new Student(20, "bb");
        studentArrayList.add(s1);
        studentArrayList.add(s2);
        
        //泛型不一样，不能赋值
//        list = studentArrayList;
    }
}

Set子接口

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

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：测试Set接口使用
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();

        //增
        set.add("xiaomi");
        set.add("huawei");
        set.add("apple");
        System.out.println("set.Size: " + set.size());
        System.out.println(set.toString());
        
        //删
//        set.remove("xiaomi");

        //遍历（重点）
        //增强for
        for (String s : set) {
            System.out.println(s);
        }
        //迭代器
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //判断
        System.out.println(set.isEmpty());
        System.out.println(set.contains("xiaomi"));
    }
}

Set实现类

HashSet

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

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：HashSet集合的使用
 *              存储结构：哈希表（数组+链表+红黑树）
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        HashSet<String> hashset = new HashSet<>();

        //增
        hashset.add("xiaomi");
        hashset.add("huawei");
        hashset.add("apple");
        //hashset.add("apple");不会重复添加
        System.out.println("Size: " + hashset.size());
        System.out.println(hashset.toString());

        //删
//        hashset.remove("xiaomi");

        //遍历（重点）
        //增强for
        for (String s : hashset) {
            System.out.println(s);
        }
        //迭代器
        Iterator<String> iterator = hashset.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //判断
        System.out.println(hashset.isEmpty());
        System.out.println(hashset.contains("xiaomi"));
    }
}

HashSet集合的使用

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：HashSet集合的使用
 *              存储结构：哈希表（数组+链表+红黑树）
 *              存储过程：(重复依据)
 *              1、根据hashcode计算保存位置，若此位置为空，直接保存，否则执行第二步
 *              2、再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        HashSet<Student> hashset = new HashSet<>();

        //增
        Student s1 = new Student(18,"aaa");
        Student s2 = new Student(19,"bbb");
        Student s3 = new Student(20,"ccc");
        hashset.add(s1);
        hashset.add(s2);
        hashset.add(s3);
        //重写了hashcode计算方法和equals方法，使得能直接new一个相同的加进去
        hashset.add(new Student(18,"aaa"));
        System.out.println("Size: " + hashset.size());
        System.out.println(hashset.toString());

        //删
//        hashset.remove("xiaomi");

        //遍历（重点）
        //增强for
        for (Student s : hashset) {
            System.out.println(s);
        }
        //迭代器
        Iterator<Student> iterator = hashset.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //判断
        System.out.println(hashset.isEmpty());
        System.out.println(hashset.contains(s1));
        System.out.println(hashset.contains(new Student(18,"aaa")));
    }
}

TreeSet

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

传入基本类型

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：TreeSet集合的使用
 *              存储结构：红黑树
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        TreeSet<String> treeSet = new TreeSet<>();

        //增
        treeSet.add("aaa");
        treeSet.add("bbb");
        treeSet.add("ccc");
        System.out.println("Size: " + treeSet.size());
        System.out.println(treeSet.toString());

        //删
//        treeSet.remove("aaa");
        //遍历（重点）
        //增强for
        for (String s : treeSet) {
            System.out.println(s);
        }
        //迭代器
        Iterator<String> iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //判断
        System.out.println(treeSet.isEmpty());
        System.out.println(treeSet.contains("aaa"));
    }
}

传入对象

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：TreeSet集合的使用
 *              存储结构：红黑树
 *              要求：元素必须实现Comparable接口,compareTo()方法返回值为0，认为是重复元素
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Student> treeSet = new TreeSet<>();

        //增
        Student s1 = new Student(18,"aaa");
        Student s2 = new Student(19,"bbb");
        Student s3 = new Student(20,"ccc");
        Student s4 = new Student(21,"ccc");
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);

        System.out.println("Size: " + treeSet.size());
        System.out.println(treeSet);

        //删
//        treeSet.remove(s1);
//        treeSet.remove(new Student(18,"aaa"));

        //遍历（重点）
        //增强for
        for (Student s : treeSet) {
            System.out.println(s);
        }
        //迭代器
        Iterator<Student> iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //判断
        System.out.println(treeSet.isEmpty());
        System.out.println(treeSet.contains(s1));
        System.out.println(treeSet.contains(new Student(18,"aaa")));
    }
}

使用Comparator

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：TreeSet集合的使用
 *              Comparator:实现定制比较（比较器）
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int i = o1.getAge() - o2.getAge();
                int j = o1.getName().compareTo(o2.getName());
                return i == 0 ? j : i;
            }
        });

        //增
        Student s1 = new Student(18,"aaa");
        Student s2 = new Student(19,"bbb");
        Student s3 = new Student(20,"ccc");
        Student s4 = new Student(21,"ccc");
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);

        System.out.println("Size: " + treeSet.size());
        System.out.println(treeSet);

        //删
//        treeSet.remove(s1);
//        treeSet.remove(new Student(18,"aaa"));

        //遍历（重点）
        //增强for
        for (Student s : treeSet) {
            System.out.println(s);
        }
        //迭代器
        Iterator<Student> iterator = treeSet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //判断
        System.out.println(treeSet.isEmpty());
        System.out.println(treeSet.contains(s1));
        System.out.println(treeSet.contains(new Student(18,"aaa")));
    }
}

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：TreeSet集合的使用
 *              Comparator:实现定制比较（比较器）
 *              实现 按照字符串长度排序
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int length = o1.length() - o2.length();
                int compare = o1.compareTo(o2);
                return length == 0 ? compare : length;
            }
        });

        //增
        treeSet.add("helloworld");
        treeSet.add("pingguo");
        treeSet.add("lisi");
        treeSet.add("wangwu");
        treeSet.add("cat");
        treeSet.add("dog");
        treeSet.add("nanjing");
        treeSet.add("guilin");
        System.out.println(treeSet);
    }
}

Map集合

特点：

用于存储任意键值对（Key-Value）
无序，无下标
键不可重复，值可重复

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：Map集合的使用
 *              entry:映射对 键值对
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        Map<String,String> map = new HashMap<>();

        //增
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("us","美国");
        System.out.println("size:" + map.size());
        System.out.println(map);

        //删
//        map.remove("uk");

        //遍历
        //使用keySet()
        System.out.println("-------------keySet----------");
        Set<String> strings = map.keySet();
        for (String key : strings) {
            System.out.println("key:" + key + " value:" + map.get(key));
        }
        //使用entrySet()
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
            System.out.println(entry);
        }

        //判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("日本"));
    }
}

HashMap（重点）

线程不安全，运行效率快，允许用nlll作为key或value

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：HashMap集合的使用
 *              存储结构：哈希表（数组+链表+红黑树）
 *              使用Key的hashcode和equals判断重复
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        HashMap<Person, String> personStringHashMap = new HashMap<>();

        //增
        Person wukong = new Person("wukong", 600);
        Person bajie = new Person("bajie", 600);
        Person shashidi = new Person("shashidi", 600);
        personStringHashMap.put(wukong, "花果山");
        personStringHashMap.put(bajie,"高老庄");
        personStringHashMap.put(shashidi,"流沙河");
        System.out.println("size:" + personStringHashMap.size());
        System.out.println(personStringHashMap);

        //删
//        personStringHashMap.remove(wukong);

        //遍历
        //使用keySet()
        System.out.println("-------------keySet----------");
        Set<Person> strings = personStringHashMap.keySet();
        for (Person key : strings) {
            System.out.println("key:" + key + " value:" + personStringHashMap.get(key));
        }
        //使用entrySet()
        Set<Map.Entry<Person, String>> entries = personStringHashMap.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
            System.out.println(entry);
        }

        //判断
        System.out.println(personStringHashMap.containsKey(wukong));
        System.out.println(personStringHashMap.containsValue("日本"));
    }
}

总结：

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

Hashtable 和 Properties

Hashtable：线程安全，运行效率慢，不允许用null作为key或value

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

TreeMap

实现了SortedMap接口（Map的子接口），可以对key自动排序

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：TreeMap集合的使用
 *              存储结构：红黑树
 *              要求元素要实现Comparable接口  或者  定制比较
 *TreeMap<Person, String> treeMap = new TreeMap<>(new Comparator<Person>() {
 *           @Override
 *           public int compare(Person o1, Person o2) {
 *               //修改比较规则
 *           }
 *       });
 */
public class Demo {
    public static void main(String[] args) {
        //创建集合
        TreeMap<Person, String> treeMap = new TreeMap<>();

        //增  要求元素要实现Comparable接口
        Person wukong = new Person("wukong", 600);
        Person bajie = new Person("bajie", 600);
        Person shashidi = new Person("shashidi", 600);
        treeMap.put(wukong, "花果山");
        treeMap.put(bajie,"高老庄");
        treeMap.put(shashidi,"流沙河");
        System.out.println("size:" + treeMap.size());
        System.out.println(treeMap);

        //删
//        personStringHashMap.remove(wukong);

        //遍历
        //使用keySet()
        System.out.println("-------------keySet----------");
        Set<Person> strings = treeMap.keySet();
        for (Person key : strings) {
            System.out.println("key:" + key + " value:" + treeMap.get(key));
        }
        //使用entrySet()
        Set<Map.Entry<Person, String>> entries = treeMap.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
            System.out.println(entry);
        }

        //判断
        System.out.println(treeMap.containsKey(wukong));
        System.out.println(treeMap.containsValue("日本"));
    }
}

Colletions工具类

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

package OOP.collection;

import java.util.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：Colletions工具类的使用
 */
public class Demo {
    public static void main(String[] args) {
        //创建
        List<Integer> list = new ArrayList<>();
        list.add(49);
        list.add(45);
        list.add(98);
        list.add(37);
        list.add(16);

        //sort排序
        System.out.println("排序前：" + list);
        Collections.sort(list);
        System.out.println("排序后：" + list);

        //binarySearch
        System.out.println(Collections.binarySearch(list, 49));

        //copy 复制  copy需要两个集合大小相同 所以先for
        List<Integer> list1 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            list1.add(list.get(i));
        }
        Collections.copy(list1,list);
        System.out.println(list1);

        //reverse反转
        Collections.reverse(list);
        System.out.println(list);

        //shuffle 打乱
        Collections.shuffle(list);
        System.out.println(list);

        //补充
        //list  ->数组
        Integer[] array = list.toArray(new Integer[list.size()]);
        System.out.println(array.length);
        System.out.println(Arrays.toString(array));
        //数组 -> 集合
        String[] names = {"wukong","wujing","wuneng"};
        //这是一个受限集合，不能添加和删除
        List<String> list2 = Arrays.asList(names);
        System.out.println(list2);

        //基本数据类型的数组转集合有问题，要变成包装类型再转换
        Integer[] nums = {1,2,3,4,5,6,7,8,9};
        List<Integer> list3 = Arrays.asList(nums);


    }
}

标签：System,println,add,Student,集合,new,out
From： https://www.cnblogs.com/shisi2001/p/18294973

集合

集合