Java 集合

集合主要技术

• 了解Collection和Map
• Collection接口
• ArrayList类
• HashSet类
• HashMap类
• Collections工具类
• 泛型

一 .Collection和Map

Collection集合继承关系图 Map集合继承关系图

线程安全：多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。

Collection

• Collection是对象集合，有两个子接口 List 和 Set，ArrayList、Vector 、LinkedList是List的实现类

• ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的。

• LinkedList是线程不安全的，底层是由链表实现的。

• ArrayList和LinkedList的操作基本一致；HashSet和LinkedHashSet的操作基本一致。

Map是键值对集合

• HashTable和HashMap是 Map 的实现类。

• HashTable是线程安全的，不能存储 null 值；HashMap 不是线程安全的，可以存储 null 值。

• HashTable的子类Properties类表示了一个持久的属性集，用于小型数据的持久化保存。

二.Collection接口

• 1.创建：由于接口不能用来实例化一个对象，所以我们实例化其子类，利用多态性接受来测试Collection接口的方法。创建的时候需要明确存放的内容是什么类型。

Collection<String> collection = new ArrayList();

• 2.添加：直接在末尾添加指定对象或者添加某个集合的内容

//末尾添加
boolean add(E e);

collection.add("Jack");
collection.add("Mary");
System.out.println(collection);

输出：[Jack, Mary]

//添加一个集合
boolean addAll(Collection<? extends E> c);

collection.clear();//清空
Collection<String> collectionTemp = new ArrayList();
collectionTemp.add("Jack");
collectionTemp.add("Mary");

collection.addAll(collectionTemp);
System.out.println(collection);

输出：[Jack, Mary]

• 3.移除：移除指定对象，移除指定集合内对象，除了指定集合内的元素外其余元素全部移除，按照指定条件移除

//移除指定对象
boolean remove(Object obj);

collection.remove("Jack");
System.out.println(collection);

输出：[Mary]

//移除指定集合对象
boolean removeAll(Collection<?> c);

Collection<Integer> collectionTemp1 = new ArrayList();
collectionTemp1.add(1);
collectionTemp1.add(2);
collectionTemp1.add(3);
Collection<Integer> temp = new ArrayList();
temp.add(1);
collectionTemp1.removeAll(temp);
System.out.println(collectionTemp1);

输出：[2, 3]

//除了指定集合内的元素外其余元素全部移除
boolean retainAll(Collection<?> c);

Collection<Integer> collectionTemp1 = new ArrayList();
collectionTemp1.add(1);
collectionTemp1.add(2);
collectionTemp1.add(3);
Collection<Integer> temp = new ArrayList();
temp.add(1);
collectionTemp1.retainAll(temp);
System.out.println(collectionTemp1);

输出：[1]

//按照指定条件移除
boolean removeIf(Predicate<? super E> p)

Collection<Integer> collectionTemp1 = new ArrayList();
collectionTemp1.add(1);
collectionTemp1.add(2);
collectionTemp1.add(3);
collectionTemp1.removeIf(obj -> obj > 2);
System.out.println(collectionTemp1);

输出：[1, 2]

• 4.获取元素个数

int size();

System.out.println(collection.size());

输出：1

• 5.判断一个元素是否包含另一个元素

boolean contains(Object obj);

if (collection.contains("Mary")) {
     System.out.println("有Mary");
}else {
     System.out.println("有Mary");
}

输出：有Mary

• 6.判断是否为空

boolean isEmpty();

//判断是否为空
if (collection.isEmpty()){
   System.out.println("是空的");
}else{
   System.out.println("不是空的");
}

输出：不是空的

• 7.判断两个集合是否相同

boolean equals(Object obj);

if (collection.equals(collectionTemp)){
    System.out.println("相同");
}else{
   System.out.println("不相同");
}

• 8.转化成不可变的普通数组

//转化成为Object类型的不可变数组
Object[] toArray();

Object[] array1 = collectionTemp.toArray();
for (Object obj : array1) {
    System.out.print((String)obj);
}

输出：JackMary

//转化成为指定类型的不可变数组
<T> T[] toArray(T[] t);

Integer[] array2 = new Integer[collectionTemp.size()];
array2 = collectionTemp.toArray(array2);
for (String str : array2) {
    System.out.print(str);
}

输出：JackMary

• 9.迭代器遍历：迭代器刚开始不指向第一个位置，下一个才是第一个位置

//获得当前集合的迭代器
Iterator<E> iterator();

//判断下一个位置是否有元素
boolean hasNext();

//指向下一个位置，并返回下一个位置的值
E next();

Iterator iterator = collectionTemp.iterator();
while (iterator.hasNext()){
    System.out.print(iterator.next());
}

//输出：JackMary

• 10.清空集合

void clear();

collection.clear();
System.out.println(collection);

输出：[]

三.ArrayList

ArrayList实现了Collection接口，Collection有的方法ArrayList都有，并且在其基础上还有更多的方法。接下里说一下ArrayList比Collection多的方法。

1.创建

ArrayList<Integer> score = new ArrayList();

2.添加

• Collection接口提供的方法

//添加指定对象
boolean add(E e);

//添加一个集合
boolean addAll(Collection<? extends E> c);

• 新的方法：在指定索引位置添加对象

public void add(int offset, E e);

score.add(2);//末尾添加
score.add(0,3);//指定位置插入
System.out.println(score);

输出：[3, 2]

3.访问指定索引位置的元素

public E get(int offset);

System.out.println(score.get(0));

输出：3

4.修改指定索引位置元素

public E set(int offset, E e);

score.set(0,1);
System.out.println(score);

输出：[1, 2]

5.返回给定对象的索引值

//返回指定对象第一次出现的索引位置
public int indexOf(Object obj)

//返回指定对象最后一次出现的索引位置
public int lastIndexOf(Object obj)

6.返回给定集合某一块的子集合

public List<E> subList(int offset, int len)

System.out.println(score.subList(0,1));

输出：[1]

7.移除

• Collection接口提供的方法

//移除指定对象
boolean remove(Object obj);

//移除指定集合对象
boolean removeAll(Collection<?> c);

//除了指定集合内的元素外其余元素全部移除
boolean retainAll(Collection<?> c);

//按照指定条件移除
boolean removeIf(Predicate<? super E> p)

• 新的方法：移除指定索引位置对象

public E remove(int offset)

• 混淆问题：操作是对象，为什么我们可以对基本类型进行操作呢。因为Java内部有装盒(例如：int->Integer)和拆盒(例如：Integer->int)的操作。

//删除指定位置的元素
score.remove(0);
System.out.println(score);
输出：[2]

//删除指定对象
score.remove((Integer) 2);
System.out.println(score);
输出：[]

8.排序

public void sort(Comparator<? super E> c)

• 排序重点是创建一个比较器对象，首先说系统提供好的升序和降序比较器。

ArrayList<Integer> list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);

//降序
list.sort(Comparator.reverseOrder());
System.out.println(list);

//升序
list.sort(Comparator.naturalOrder());
System.out.println(list);

输出：
[6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6]

• 根据想要比较的对象创建

list.sort(Comparator.reverseOrder());
System.out.println(list);

//升序
list.sort(Comparator.comparing(Integer::intValue));
System.out.println(list);

输出：
[6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6]

• 自己创建一个类实现Comparator接口

class XLCompare implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        int mo1 = (int)o1;
        int mo2 = (int)o2;

        return mo1 - mo2;
    }
}

list.sort(Comparator.reverseOrder());
System.out.println(list);

list.sort(new XLCompare());
System.out.println(list);

输出：
[6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6]

• 使用匿名类完成：什么时候需要自己手动创建比较器，如果系统默认提供的方法不能完成我们的比较

list.sort(Comparator.reverseOrder());
System.out.println(list);

list.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer integer, Integer t1) {
        return integer-t1;
    }
});
System.out.println(list);

输出：
[6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6]

• 使用Lambda 表达式

list.sort(Comparator.reverseOrder());
System.out.println(list);

list.sort((Integer i1,Integer i2)->i1-i2);
System.out.println(list);

• 例子：比较两个自定义的对象

public class Person {
    String name;
    int age;

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

class XLCompare implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        Public p1 = (Public)o1;
        Public p2 = (Public)o2;
        
        if(p1.age != p2.age){
             return p1.age - p2.age;
        }else{
             return p1.name - p2.name;
        }
    }
}

ArrayList<Person> list = new ArrayList();

String[] names = {"张明","张杰","李明浩","李浩天","李隆基","李世明"};

for (int i = 0; i < names.length; i++) {
    Person person = new Person(names[i],i+30);
    list.add(person);
}

list.sort(new XLCompare());

四.HashSet

1.简述

• Set里面元素不能重复，如果重复添加不进去；其内部使用HashMap来实现，键值对中键key不能重复。内部是通过计算每个key的hash值，是在对象的地址的基础上得到的值；Object类有一个方法public native int hashCode();用来返回hash值；切记重写类的equals方法一定要重写hashCode方法，hashCode和equals详解。Object类还有一个方法protected native Object clone() throws CloneNotSupportedException;用于复制对象，clone详解。

• Set是无序的，添加的顺序和存储的顺序无关；而ArrayList添加的顺序和存储的顺序有关。

• Hash大部分的操作可以参照Collection接口。

• HashSet内部的顺序是按照默认的顺序排列的；TreeSet则可以使用我们给定的顺序排列。

2.HashSet代码例子

HashSet<String> hashSet = new HashSet<>();

hashSet.add("java");
hashSet.add("java");
hashSet.add("jack");
hashSet.add("Android");
System.out.println(hashSet);
//[java, jack, Android]

hashSet.removeIf(element->element.compareTo("c") > 0);
System.out.println(hashSet);
//[Android]

3.TreeSet代码例子

• 可以在TreeSet的构造方法中传入一个比较器Comparator，这又涉及到Comparator和Comparable两个接口的区别

• Comparator 则是在外部制定排序规则，然后作为排序策略参数传递给某些类，例如ArrayList的sort方法，TreeSet的构造方法。

• 自然排序需要类实现 Comparable，并且在内部重写 comparaTo 方法。Object类有一个用于比较的方法public boolean equals(Object var1) {return this == var1;}，就需要类实现 Comparable。系统内部的类基本上都实现了Comparable接口，如果我们自定义的类需要比较，那么一定要实现 Comparable接口。

class Person implements Comparable{
    String name;
    int age;

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

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

    //equals比较的是对象内部的内容
    //所有的对象要能参加比较，必须实现Comparable
    //接口compareTo方法
    //在compareTo中做具体的比较
    @Override
    public int compareTo(Object o) {
        //判断o对象是不是Person的一个对象
        if (o instanceof Person){
            //自己规定返回的策略
            if (this.age != ((Person) o).age){
                return this.age-((Person) o).age;
            }else {
                //年龄相同的情况下再比姓名
                return this.name.compareTo(((Person) o).name);
            }
        }else {
            return -1;
        }
    }
}

TreeSet<Integer> score = new TreeSet<>();

score.add(32);
score.add(45);
score.add(12);
System.out.println(score);
//[12, 32, 45]

//Lambda表达式方式
TreeSet<Person> persons = new TreeSet<>((Person p1,Person p2)->p1.compareTo(p2));

//匿名类方式
/*TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {
    @Override
    public int compare(Person person, Person t1) {
        return person.compareTo(t1);
    }
});*/

Person p1 = new Person("仙王",18);
Person p2 = new Person("武帝",18);
Person p3 = new Person("开天",18);

persons.add(p1);
persons.add(p2);
persons.add(p3);

System.out.println(persons);

输出：[Person{name='仙王', age=18}, Person{name='开天', age=18}, Person{name='武帝', age=18}]

五.HashMap

一.概述

• HashMap集合存储数据的特点：键key-值value

• key不能重复，可以是任意的对象类型，通常使用字符串

二.方法

• 1.创建对象：需要制定键和值得类型。

HashMap<String,Integer> score = new HashMap<>();

• 2.添加键值对：添加的键值相同的情况，后面的默认更改值。

public V put(K key, V value)

添加一个HashMap

public void putAll(Map<? extends K, ? extends V> m)

//添加对象：键值对
score.put("Chinese",90);
score.put("English",88);
score.put("Math",100);

//相同的情况，默认更改其值
score.put("Chinese",95);
System.out.println(score);

输出：{English=88, Chinese=95, Math=100}

• 3.获取键值对的个数

public int size()

System.out.println(score.size());

输出：3

• 4.获取所有的key

public Set<K> keySet()

System.out.println(score.keySet());

输出：[English, Chinese, Math]

• 5.获取所有的value

public Collection<V> values()

System.out.println(score.values());

输出：[88, 95, 100]

• 6.获取一个键对应的值，如果key不存在，返回null

public V get(Object obj)

System.out.println(score.get("Chinese"));

输出：95

• 7.返回包含映射的Set视图。

public Set<Entry<K, V>> entrySet()

System.out.println(score.entrySet());

输出：[English=88, Chinese=95, Math=100]

• 8.键值对的遍历

//1.通过遍历key得到每一个key对应的值
for (String key : score.keySet()) {
    //通过key得到值
    int value  = score.get(key);
    System.out.println("key："+key+" "+"value；"+value);
}

输出：
key：English value；88
key：Chinese value；95
key：Math value；100

//2.通过entrySet 得到Entry对象的集合
//一个entry管理一个键值对 getKey getValue
Set<Map.Entry<String ,Integer>> entrys = score.entrySet();
for (Map.Entry entry : entrys) {
    //得到entry对应的key
    String key = (String)entry.getKey();
    //得到entry对应的value
    Integer value = (Integer)entry.getValue();
    System.out.println("key："+key+" "+"value；"+value);
}

输出：
key：English value；88
key：Chinese value；95
key：Math value；100

• 9.删除制定键对应的映射关系

public V remove(Object obj)

score.remove("Chinese");
System.out.println(score);

输出：{English=88, Math=100}

• 10.替换指定键对应的值

public V replace(K key, V value)

score.replace("English",90);
System.out.println(score);

输出：{English=90, Math=100}

• 11.判断是否为空

public boolean isEmpty()

• 12.清空所有映射关系

public void clear();

六.Collections工具类

• 1.获取List中的最小值

List<Integer> intList = Arrays.asList(33, 24, 18, 6, 9, 99);  
// 6  
System.out.println(java.util.Collections.min(intList));  

• 2.获取List中的最大值

List<Integer> intList = Arrays.asList(33, 24, 18, 6, 9, 99);  
// 99  
System.out.println(java.util.Collections.max(intList));  

• 3.Shuffle方法可以使一个集合的元素乱序化。

List<Integer> intList = Arrays.asList(33, 24, 18, 6, 9, 99);  
Collections.shuffle(intList);  
// 一次测试的结果  
// [6, 18, 33, 24, 99, 9]  
System.out.println(intList); 

• 4. nCopies返回一个不可变列表组成的n个拷贝的指定对象。

// 生成一个由10个100组成的整数列表  
List<Integer> nCopiesList = Collections.nCopies(10, 100);  
//[100, 100, 100, 100, 100, 100, 100, 100, 100, 100]  
System.out.println(nCopiesList);  

• 5.sort用于对集合排序。

List<Integer> intList = Arrays.asList(33, 24, 18, 6, 9, 99);  
Collections.sort(intList);  

• 6.binarySearch用于查找给定元素在给定数组的索引值。

List<Integer> intList = Arrays.asList(33, 24, 18, 6, 9, 99);  
// 2  
System.out.println(Collections.binarySearch(intList, 18));  

• 7.frequency获取某个元素在集合出现的次数。

List<String> testList = Arrays.asList("A", "B", "C", "D");  
int freq = Collections.frequency(testList, "A");  
// 1  
System.out.println(freq); 

• 8.indexOfSubList返回指定源列表中第一次出现指定目标列表的起始位置。

int index = Collections.indexOfSubList(Arrays.asList("A", "B", "C"),  
Arrays.asList("B"));  
// Print 1  
System.out.println(index);  

• 9.lastIndexOfSubList返回指定源列表中最后一次出现指定目标列表的起始位置。

int lastIndex = Collections.lastIndexOfSubList(  
        Arrays.asList("A", "B", "C", "B"), Arrays.asList("B"));  
// Print 3  
System.out.println(lastIndex);  

• 10.reverse反转列表中的元素顺序。

List<String> reverseCandidate = Arrays.asList("A", "B", "C");  
Collections.reverse(reverseCandidate);  
// [C, B, A]  
System.out.println(reverseCandidate);  

• 更多的方法

七.泛型

1.泛型方法

• 泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。

• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。

• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。

• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

public class GenericMethodTest{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray ){
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] ){
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

输出：
整型数组元素为:
1 2 3 4 5 

双精度型数组元素为:
1.1 2.2 3.3 4.4 

字符型数组元素为:
H E L L O 

2.泛型类

• 泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

• 和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。

• 一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。

public class MyClass {

    public static void main(String[] args){
        //创建类，明确指定T指定的类型
        GenericTest<String> genericTest = new GenericTest<>();

        genericTest.test("java","oc");

        System.out.println(genericTest.a1);
    }
}

class GenericTest<T>{
    int age;
    T a1;
    T a2;

    public void test(T a1,T a2){
        this.a1 = a1;
        this.a2 = a2;

        System.out.println(a1.equals(a2));
    }
}

3.类型通配符

类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类。

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

输出：
data :icon
data :18
data :314