java19-集合-Toy模板网

这篇具有很好参考价值的文章主要介绍了java19-集合。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

集合

集合概述

面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象操作，就要对对象进行存储
使用Array存储对象方面有一些弊端，而集合就像一个容器，可以动态的把多个对象的引用放入容器中

集合框架

Collection接口（单列集合，用来存储一个一个的对象）

创造集合

     Collection coll=new ArrayList();
        // add(Object e);
        coll.add("123");
        coll.add(123);
        coll.add(new  Date());
        coll.add(new Person1("jack",20));

        // size
        System.out.println(coll.size());
        // 4

常用方法


import org.junit.Test;

import java.util.*;

public class CollectionTest {
    @Test
    public void test1(){
        Collection coll=new ArrayList();
        // add(Object e);
        coll.add("123");
        coll.add(123);
        coll.add(new  Date());
        coll.add(new Person1("jack",20));

        // size
        System.out.println(coll.size());
        // 4

        // contains(Object obj)
        // 我们在判断时会调用obj对象所在类的equals()
        boolean contains = coll.contains(123);
        System.out.println(contains);
        // true
        System.out.println(coll.contains(new Person1("jack",20)));
        // true

        // containsAll(Collection coll) 形参coll中所有元素都在当前集合中
        Collection coll1= Arrays.asList(123,"123");
        System.out.println(coll.containsAll(coll1));
        // true

        // remove(Object obj) 移除某个元素 （也会调equals()）
        System.out.println(coll);
        // [123, 123, Thu Dec 08 22:34:36 CST 2022, Person1{name='jack', age=20}]
        coll.remove(123);
        System.out.println(coll);
        // [123, Thu Dec 08 22:34:36 CST 2022, Person1{name='jack', age=20}]

        // removeAll(Collection coll) 移除当前集合中形参coll中所有元素

    }
    @Test
    public void test2(){
        Collection coll1=new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(789);
        Collection coll2=Arrays.asList(123,789);
        // retainAll(Collection coll); 获取当前集合与coll的交集，并返回给当前集合
        coll1.retainAll(coll2);
        System.out.println(coll1);
        //[123, 789]

        // equals(Object obj) 当前集合和形参集合元素相同
        Collection coll3=new ArrayList();
        coll3.add(123);
        coll3.add(789);
        System.out.println(coll3.equals(coll2));
        // true

    }
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("123");
        coll.add(true);
        // hashCode() 返回当前对象的哈希值
        System.out.println(coll.hashCode());
        // 1658615

        // 集合=>数组 toArray()
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
            //123
            //123
            //true
        }

        // 数组=>集合 调Arrays类的静态方法asList()
        List<String> strings = Arrays.asList(new String[]{"123", "456"});
        System.out.println(strings);
        // [123, 456]

    }
    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("123");
        coll.add(true);
        // iterator()返回Iterator接口的实例，用于遍历集合元素，每次都是一个新的迭代器对象
        Iterator iterator = coll.iterator();
        System.out.println(iterator.next());
        // 123

        // hasNext() 是否还有元素
        while (iterator.hasNext()){
            // next() 指针下移，并返回下移后当前元素
            System.out.println(iterator.next());
        }
    }
}
class Person1{
    private String name;
    private int age;
    public Person1(String name,int age) {
        this.name=name;
        this.age=age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person1 person1 = (Person1) o;
        return age == person1.age && Objects.equals(name, person1.name);
    }

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

forEach循环循环遍历集合


import org.junit.Test;

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

public class forEachTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add("123");
        coll.add(true);
        // for (集合元素类型 局部变量 ： 集合对象)
        for (Object obj:coll){
            System.out.println(obj);
        }
    }
    @Test
    public void test2(){
        int[] arr=new int[]{1,2,3};
        for (int i:arr){
            System.out.println(i);
        }
    }
}

List接口（存储有序的，可重复数据）

List接口实现类常用有ArrayList,LinkedList,Vector

方法	特点
ArrayList	作为list主要实现类，线程不安全，效率高。底层使用Object[]存储
LinkedList	对于频繁的插入，删除操作，比ArrayList效率高，底层使用双向链表存储
Vector	作为list古老实现类，线程安全，效率低。底层使用Object[]存储

List常用方法

import org.junit.Test;

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

public class listTest {
    @Test
    public void test1() {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add("123");
        list.add(123);
        System.out.println(list);
        //[123, 123, 123]

        // void add(int index,Object obj):在index位置插入obj
        list.add(1, 456);
        System.out.println(list);
        // [123, 456, 123, 123]

        // boolean addAll(int index,Collection coll):从index位置将coll所有元素添加
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list);
        // [123, 456, 123, 123, 1, 2, 3]

        // Object get(int index):获取指定位置的元素
        Object obj = list.get(1);
        System.out.println(obj);
        // 456

        // int indexOf(Object obj):获取obj首次出现位置返回
        int index = list.indexOf(123);
        System.out.println(index);
        // 0

        // int lastIndexOf(Object obj):获取obj最后出现位置返回
        int index1 = list.lastIndexOf(123);
        System.out.println(index1);
        // 3

        //Object remove(int index):移除index位置元素，并返回移除元素
        Object remove = list.remove(1);
        System.out.println(remove);
        // 123

        // Object set(int index,Object obj):设置index位置的元素为obj
        list.set(1, "set");
        System.out.println(list);
        // [123, set, 123, 1, 2, 3]

        // list subList(int fromIndex,int toIndex):返回从fromIndex到toIndex元素子集合
        List list2 = list.subList(1, 3);
        System.out.println(list2);
        // [set, 123]
    }
}

Set接口（存储无序的，不可重复数据）

方法	特点
HashSet	作为set主要实现类，线程不安全，可以存储null
LinkedHashSet	作为HashSet子类，遍历其内部数据时，可以按照添加顺序遍历
TreeSet	可以按照添加对象指定属性排序

无序性和不可重复

无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引顺序添加，而是根据数据哈希值
不可重复：保证添加的元素按照equals方法判断时不能返回true，即相同元素只能有一个

set中没有新增方法，都是collection中方法
TreeSet的排序

自然排序：比较两个对象是否相等的标准为compareTo()返回为0，不再是equals()


import org.junit.Test;

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

public class TreeSetTest {
    @Test
    public void test1(){
        TreeSet treeSet = new TreeSet();
        treeSet.add(new User("jack",10));
        treeSet.add(new User("tom",23));
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
            //User{name='jack', age=10}
            //User{name='tom', age=23}
        }
    }
}
class User implements Comparable{
    public String name;
    public Number age;
    public User(String name,Number age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public Number getAge() {
        return age;
    }

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

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

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

    // 按照姓名从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user=(User) o;
            return this.name.compareTo(user.name);
        }else {
            throw new RuntimeException("输入类型不匹配");
        }
    }
}

定制排序：比较两个对象是否相等的标准为compare()返回为0，不再是equals()

Map接口（双列集合，用来存储一对一对的数据（key-value））

HashMap：作为Map主要实现类，线程不安全，效率高，存储null的key和value
- linkedHashMap：保证在遍历Map元素时，可以按照添加顺序遍历。原理在原有的HashMap底层结构基础上，添加了一对指针指向前一个和后一个元素。对于频繁的遍历操作，此类效率高于HashMap

import org.junit.Test;

import java.util.HashMap;
import java.util.LinkedHashMap;

public class MapTest { 
    @Test
    public void test2(){
        HashMap map = new HashMap();
        map.put(123,"aa");
        map.put(23,"bb");
        map.put(3,"cc");
        System.out.println(map);
        // {3=cc, 23=bb, 123=aa}
        HashMap map2 = new LinkedHashMap();
        map2.put(123,"aa");
        map2.put(23,"bb");
        map2.put(3,"cc");
        System.out.println(map2);
        // {123=aa, 23=bb, 3=cc}
    }
}

TreeMap：保证按照添加的Key-Value对进行排序，实现排序遍历，要求key必须是同一个类的实例
Hashtable：作为古老的实现类，线程安全，效率低,不能存储null的key和value
- Properties：常用来处理配置文件。key和value都是String类型

Map结构

Map中的key：无序的，不可重复的，使用Set存储所有的key==>key所在的类重写equals()和hashCode()
Map中的value：无序的，可重复的，使用Collection存储的所有的value==>value所在的类重写equals()
一个键值对：key-value构成了一个Entry对象
Map中的Entry：无序的，不可重复的，使用set存储所有的entry

HashMap底层结构

对于jdk7

HashMap map = new HashMap();底层创建一个长度是16的一维数组Entry[] table
map.put(key.value)
- 调用key所在类的hashCode()计算key的哈希值，此哈希值经过算法后，得到Entry数组中存放位置
  - 如果位置上数据为空，key-value添加成功
  - 如果此位置数据不为空，意味着此位置上存在一个或者多个数据（以链表形式存在），比较key和已有数据的hash值
    - 如果key的Hash值与已经存在的数据的哈希值都不相同，此时数据添加成功
    - 如果key的Hash值与某个数据的Hash值相同，继续比较key的equlas(key2)，如果返回false，此时添加成功；如果返回true，替换调value
      对于jdk8
new HashMap()底层没有创建一个长度为16的数组
jdk8底层数组是node[]
首次调用put()时，创建底层长度为16数组
jdk底层结构：数组+链表+红黑树。当数组某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64，此时此索引位置上的所有数据改为使用红黑树存储

Map常用方法

方法	含义
Object put(Object key,Object value)	将指定的key-value添加（或修改）到map对象中
void putAll(Map m)	将Map中所有的key-value对存放到当前map对象中
Object remove(Object key)	移除指定的key-value对，并返回Value
void clear()	清空当前map中所有数据
Object get(Object key)	获取指定key对应的value
Boolean containsKey(Object key)	是否包含对应的key
Boolean containsValue(Object value)	是否包含对应的value
int size()	返回map中的key-value的对数
Boolean isEmpty()	判断当前对象map是否为空
Boolean equals(Object obj)	判断当前map和参数对象obj是否相等
Set keySet()	返回所有key构成的Set集合
Collection values()	返回所有value构成的集合
Set entrySet()	返回所有key-value对构成的Set集合

import org.junit.Test;

import java.util.*;

public class MapTest {
    @Test
    public void test3(){
        HashMap hashMap = new HashMap();
        hashMap.put("AA",12);
        hashMap.put(12,"AA");
        hashMap.put("AA",123);
        System.out.println(hashMap);
        // {AA=123, 12=AA}
        HashMap hashMap1 = new HashMap();
        hashMap1.put("BB",12);
        hashMap.putAll(hashMap1);
        System.out.println(hashMap);
        // {AA=123, BB=12, 12=AA}
        Object value = hashMap.remove("AA");
        System.out.println(value);
        // 123
        System.out.println(hashMap);
        // {BB=12, 12=AA}
        hashMap.clear();
        System.out.println(hashMap);
        // {}
        HashMap hashMap2 = new HashMap();
        hashMap2.put("AA",123);
        hashMap2.put("BB",123);
        Object key = hashMap2.get("AA");
        System.out.println(key);
        Boolean isExist = hashMap2.containsKey("AA");
        System.out.println(isExist);
        isExist = hashMap2.containsValue(123);
        System.out.println(isExist);
        int size = hashMap2.size();
        System.out.println(size);
        boolean empty = hashMap2.isEmpty();
        System.out.println(empty);
        Set set = hashMap2.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
            // AA BB
        }
        Collection values = hashMap2.values();
        for (Object obj: values){
            System.out.println(obj);
            // 123 123
        }
        Set set1 = hashMap2.entrySet();
        Iterator iterator1 = set1.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            // entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+"="+entry.getValue());
            // AA=123
            // BB=123
        }
    }
}

Properties

Properties类是Hashtable的子类，该对象用于处理属性文件
由于属性文件key-value是字符串类型，所以Properties的key-value是字符串类型
用getProperty(String key)和setProperty(String key,String value)

import java.io.FileInputStream;
import java.util.Properties;

public class properties {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        FileInputStream fileInputStream = new FileInputStream("jdbc.properties");
        properties.load(fileInputStream);
        String name = properties.getProperty("name");
        String password = properties.getProperty("password");
        System.out.println("name="+name+"password"+password);
        // name=jackpassword123

    }
}

collections工具类

Collections是一个操作Set，List和Map等集合的工具类

方法	含义
reverse(list)	反转list中元素顺序
shuffle(list)	对list集合顺序随机排序
sort(list)	根据元素的自然顺序对list集合元素进行升序排列
sort(list,Comparator)	根据指定的Comparator产生的顺序对list集合进行排序
swap(list,int,int)	将指定list的i元素和j元素交换
Object Max(Collection)	根据自然排序，返回最大值
Object Max(Collection,Comparator)	根据Comparator指定的顺序，返回最大值
Object Min(Collection)	根据自然排序，返回最小值
Object Min(Collection,Comparator)	根据Comparator指定的顺序，返回最小值
int frequency(Collection Object)	返回指定集合中指定元素出现的次数
void copy(list dest,list src)	将src内容复制到dest中
bollean replaceAll(List list,Object oldVal,Object newVla)	使用新值替换list中的旧值

import org.junit.Test;

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

public class CollectionsTest {
    @Test
    public void test1(){
        ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(234);
        arrayList.add(345);
        System.out.println(arrayList);
        // [123, 234, 345]
        Collections.reverse(arrayList);
        System.out.println(arrayList);
        // [345, 234, 123]
//        Collections.shuffle(arrayList);
//        System.out.println(arrayList);
//        // [345, 123, 234]
        Collections.swap(arrayList,1,2);
        System.out.println(arrayList);
        // [345, 123, 234]
    }
    @Test
    public void test2(){
        ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(234);
        arrayList.add(345);
        List<Object> dest =  Arrays.asList(new Object[arrayList.size()]);
        // dest.size必须大于arrayList.size
        Collections.copy(dest,arrayList);
        System.out.println(dest);
        // [123, 234, 345]
    }
}

同步操作

Collections提供多个synchronizedXXX方法，该方法可以将指定集合包装成线程同步集合，从而可以解决多线程访问集合线程安全问题文章来源地址https://www.toymoban.com/news/detail-733234.html

Collection c = Collections.synchronizedCollection(new ArrayList());
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());
Map map = Collections.synchronizedMap(new HashMap());