首页 > 资讯 > 后端开发 > Python >Java十分钟精通集合的使用与原理下篇

771

分享到

Java十分钟精通集合的使用与原理下篇

2024-04-02 19:04:59 771人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

List集合： ArrayList：底层是数组结构，储存有序并且可以重复的对象 package SetTest; import java.util.ArrayList; imp

List集合：

ArrayList：

底层是数组结构，储存有序并且可以重复的对象


package SetTest;

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

public class ArrayListTest {
    public static void main(String[] args) {

		//创建ArrayList的对象
        List<Integer> list = new ArrayList<>();  
        //使用add方法就可以添加
        list.add(1);
        list.add(2); //是可以重复的
        list.add(2);
        list.add(3);
        list.add(4);
        
        //使用集合工具类Collections
        Collections.sort(list); //排序
        Collections.reverse(list); //反转
        System.out.println(list.toString());

    }
}

输出：

[1, 2, 2, 3, 4]
[4, 3, 2, 2, 1]
//在ArrayList中重复数据是没问题的

LinkedList：

双向链表式存储，存储有序可重复的对象。LinkedList的实现机制与ArrayList的不同，ArrayList底层是数组实现的，每次插入值的时候先扩容数组的长度，通过下标获取到该数组的值因此查询元素的效率很高，但是插入和删除需要位移效率很低，所以经常对元素插入或者删除操作建议不要使用ArrayList，而要采用LinkedList。LinkedList采用双向链表式存储在增加和删除元素的时候不需要位移，插入和删除效率高。

LinkedList的储存结构：

总结：查询多的时候用ArrayList，删除和插入多就用LinkedList


List<Integer> list = new LinkedList<>();//创建LinkedList的对象

其他操作与ArrayList一致

Vector：

Vector和ArrayList集合没有什么太大的区别，底层都是数组实现的，作用也是一致，用来存储大量的有序的可重复的对象，一般用于大量数据的查询。唯一的区别在于Vector是线程安全的，ArrayList是非线程安全的。


 List<Integer> list = new Vector<>();//创建Vector的对象

其他操作与ArrayList一致

Set集合：

HashSet：

是以Hash算法来记录再内存中无序存储的对象

HashSet源码：


public HashSet() {
	map = new HashMap<>();
}

说明HashSet底层是依赖于HashMap以键值对的形式来存储的无序的集合，通过键来找到值，但是键是以hash算法来存储的无序集合。

TreeSet:

TreetSet是SortSet接口的实现类，TreeSet可以保证元素处于排序状态再保存。它采用的是红黑树算法数据结构来存储集合元素。TreeSet支持两种排序：自然排序和定制排序，默认采用自然排序

自然排序：


package SetTest;

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

public class TreeSetTest {
    public static void main(String[] args) {

        //treeSet是以红黑树算法将值先排序再保存
        Set<Integer> tre = new TreeSet<>();
        tre.add(5);
        tre.add(3);
        tre.add(8);
        tre.add(1);
        tre.add(4);
        for (Integer val:tre){
            System.out.println(val);
        }
    }
}

输出：

1
3
4
5
8

定制排序：

Student类：


package TreeSet;

public class Student implements Comparable<Student> {

    private String name;
    private int age;
    private char sex;

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

    @Override
    public String toString(){
        return "学生的信息是{"+name+age+sex+"}";
    }

    @Override
    public int compareTo(Student obj) {
        //这里使用年龄来比较排序
        int num = this.age-obj.age;
        return num;
    }
}

测试类：


package TreeSet;

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

public class test {
    public static void main(String[] args) {
		
		//这里生成对象的年龄不按照大小来生成
        Student stu1 = new Student("张三",40,'男');
        Student stu2 = new Student("李四",32,'男');
        Student stu3 = new Student("王五",25,'男');

        Set<Student> treeSet = new TreeSet<>();
        treeSet.add(stu1);
        treeSet.add(stu2);
        treeSet.add(stu3);

        for (Student stu:treeSet
             ) {
            System.out.println(stu.toString());

        }
    }
}

输出结果：

结果就是按照年龄的大小来进行排序：（这个就是TreeSet的定制排序）

学生的信息是{王五25男}
学生的信息是{李四32男}
学生的信息是{张三40男}

LinkedHashSet：

内部是一个双向链表式结构，所以它插入的值式有序的。因为它插入的时候是使用链表式维护插入的顺序，所以获取元素的时候应该和插入的顺序一致。但是LinedHashSet性能上低于HashSet，因为除了维护值以外还需要维护他们的顺序：


package SetTest;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetTest {
    public static void main(String[] args) {

        //LinkedHashSet 按照插入的顺序读取值
        Set<Integer> set = new LinkedHashSet<>();
        set.add(40);
        set.add(20);
        set.add(10);
        set.add(30);
        
        for (Integer val:set){
            System.out.println(val);
        }
    }
}

输出：（会按照输入的顺序去读值）

40
20
10
30

Map集合：

HashMap：


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

public class MapTest {
    public static void main(String[] args) {
    
        Map<String,String> map = new HashMap<>();
        map.put("red","红色");
        map.put("yellow","黄色");
        map.put("green","绿色");
        
        System.out.println(map);
        
        System.out.println(map.get("yellow"));//通过get键去获取值

	}
}

输出：

{red=红色, green=绿色, yellow=黄色}
黄色 // System.out.println(map.get("yellow"));

HashMap的两种遍历方法：

通过for遍历所有的键，根据键来获取到值（接上部分代码即可）


   for (String stu:map.values()
             )
            System.out.println(stu.toString());{
        }

输出：

红色
绿色
黄色

用迭代器的方式：（接上部分代码即可）


        Set<String> keys = map.keySet();
        Iterator<String> it = keys.iterator();
        while(it.hasNext()){
            String key = it.next();
            String stu = map.get(key);
            System.out.println(stu.toString());
}

输出：

红色
绿色
黄色

注意：如果是存储大量的数据，我们一般是不会用Map去存储。Map一般用于存储小量并且可以无序的键值对存储的数据。比如登录页面的用户名、密码等等。

LinkedHashMap：

LinkedHashMap是以链表式存储的HashMap，并且是以Hash算法来获取hashcode的值来获取内存中的数据，存储的顺序和读取的顺序一致：


import java.util.LinkedHashMap;
import java.util.Map;
public class LinkHashMap {

    public static void main(String[] args) {

		//在HashMap里面，添加使用put方法！！        
        Map<String,String> map = new LinkedHashMap<>();
        map.put("yellow","黄色");
        map.put("green","绿色");
        map.put("red","红色");
        System.out.println(map);
    }
}

输出：

{yellow=黄色, green=绿色, red=红色}

HashTable：


Map<String,String> map = new Hashtable<>();

HashMap和HashTable的作用一样，都是无序的键值对形式存储，HashTable考虑线程安全，HashMap不考虑线程安全，其他操作一致。

ConcurrentHashMap: 也是和HashMap线程一样，但是它考虑线程安全。HashTable是采用给当前线程加锁实现线程安全， ConcurrentHashMap是采用分段锁机制来实现线程安全：


Map<String,String> map = new ConcurrentHashMap<>();

EnumMap：

专门用来存储枚举的Map集合：


package SetTest;
import java.util.Map;
public class EnumMap {

    //枚举
    public enum color{
        RED,GREEN,YELLOW
    }
    public static void main(String[] args) {

        //枚举map
        Map<color,String> map = new java.util.EnumMap<color, String>(color.class);
        map.put(color.RED,"红灯");
        map.put(color.GREEN,"绿灯");
        map.put(color.YELLOW,"黄灯");
        System.out.println(color.RED);
        String info = map.get(color.RED);
        System.out.println("信号信息是："+info);

    }
}

集合和数组之间的转换：


import com.sun.corba.se.spi.ior.ObjecTKEy;
import java.util.Arrays;
import java.util.List;



public class SetToArr {
    public static void main(String[] args) {
        String name [] =  new String[]{"张三","李四","王五","赵六"};

        //将各种数据转换成list集合
        List<String> list1 = Arrays.asList(name);
        List<String> list2 = Arrays.asList("aa","bb","cc");
        List<Integer> list3 = Arrays.asList(100,200,300);
        System.out.println("list集合："+list2);

        //list转数组
        Object [] newArr = list2.toArray();
        String newStr = list2.toString();
        System.out.println("数组："+newStr);



    }
}

输出：