java集合汇总

最新推荐文章于 2024-07-17 19:25:55 发布

浓眉哥23

最新推荐文章于 2024-07-17 19:25:55 发布

阅读量255

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/weixin_39420175/article/details/105160367

版权

Java集合类存放于Java.util包中，是一个用来存放对象的容器。
（1）集合只能存放对象，如果存一个int型数据1放入集合中，会自动转换成Integer类型存入，Java中每个基本数据类型都有对应的引用类型；
（2）集合存放的是对象的引用，对象本身还是存放在堆中；
（3）集合可以存放不同类型，不限数量的数据类型；
总之，集合就是一个可以存放若干个引用数据类型变量的类，这些变量可以属于不同类型。
Java集合可以分为：
（1）Set：无序、不可重复的集合；
（2）List：有序，可重复的集合；
（3）Map：具有映射关系的集合；

1.HashSet集合

HashSet集合无序、不可重复、不是线程安全且集合元素可以为null；
无序：当向HashSet集合存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该元素的hashCode值，然后根据hashCode值来决定该对象在HashSet中的存储位置，所以在集合中存储的数据不一定是存入时的顺序；
不可重复：如果两个元素的equals()方法返回true，但是hashCode()返回值不相等，hashSet会把它们存储在不同的位置（一般来说true相等，false不相等）

创建一个HashSet的引用对象，这个引用就是一个HashSet集合

import java.util.HashSet;

public class Test7 {
      HashSet set = new HashSet();
}

添加元素并输出当前集合

       set.add(1);
       set.add('a');
       System.out.println(set);

移除集合中的元素

         set.remove(1);
         System.out.println(set);

判断是否包含某个元素

         System.out.println(set.contains('a'));
         System.out.println(set.contains(1));

清空集合

       set.clear();

使用迭代器遍历集合

         Iterator it = set.iterator();//iter+ alt+/
         while(it.hasNext()){
        	 System.out.println(it.next());
         }

for-each 遍历集合

         for(Object obj: set){
        	System.out.println(obj); 
         }

获取集合元素个数

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

集合元素不能重复，如果输入两个1，集合中元素的个数还是1

可以在集合中存入null

         set.add(null);
         System.out.println(set);
         //输出[null, 1, a]（因此不保证顺序）

如果想要让集合只能存相同类型的对象，需要使用泛型

        Set<Integer> set = new HashSet<Integer>();
		set.add(1);
		set.add(2);
		set.add("qq");//插入错误
		
//Set set = new HashSet();
//相当于Set<Object>set = new HashSet<Object>();

2. TreeSet集合

TreeSet集合可以确保集合元素处于排序状态；
TreeSet支持两种排序方法：自然排序（默认）和定制排序

自然排序

public class Test3 {
       public static void main(String[] args) {
		Set<Integer> set = new TreeSet<Integer>();//alt+/
		//TreeSet默认情况下自然排序
		set.add(5);
		set.add(2);
		set.add(4);
		set.add(3);

TreeSet调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系。然后将元素按升序排列
（1）this>obj，返回正数1
（2）this<obj，返回负数-1
（3）this=obj，返回0，认为两个数相等
必须放入同样类的对象（默认会进行排序），否则可能会发生类型转换异常，可以使用泛型来进行限制

		System.out.println(set); //输出：[2, 3, 4, 5]
		set.remove(5);
		System.out.println(set);//输出[2, 3, 4]
		System.out.println(set.contains(0));//输出false
		set.clear();
		System.out.println(set);//输出[]

迭代遍历集合

//使用迭代器遍历集合
		Iterator<Integer> it = set.iterator();//Iter+alt+/
		while (it.hasNext()){
		System.out.println(it.next());
		                }
//for each 迭代集合
		for(Integer it1 : set){
		//把 set中的元素取出，赋给obj
		System.out.println(it1);
				}
	}
}

定制排序

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

public class Test3 {
       public static void main(String[] args) {
		Person p1 = new Person("张三",21);
		Person p2 = new Person("李四",12);
		Person p3 = new Person("王五",26);
		Person p4 = new Person("qq",19);
		Set<Person> set = new TreeSet<Person>(new Person());
		set.add(p1);
		set.add(p2);
		set.add(p3);
		set.add(p4);
		for(Person p : set){
			System.out.println(p.name+"   "+p.age);
		}
	}
}
class Person implements Comparator<Person>{
     int age;
     String name;
     public Person(){
    	 
     }
     public Person(String name,int age){
    	 this.age = age;
    	 this.name = name;
     }
	@Override
	public int compare(Person o1, Person o2) {
		//年龄正序排列
		if (o1.age > o2.age){
			//颠倒顺序可以倒序排列
			return 1;
		}else if (o1.age < o2.age){
			return -1;
		}else
		    return 0;
	}
}

3.List集合

List代表一个有序可重复的集合，集合中的每一个元素都有其对应的顺序索引，元素可以重复，可以通过索引来访问指定位置的元素；默认按元素的添加顺序设置索引

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

public class Test4 {
       public static void main(String[] args) {
		List<String> list= new ArrayList<String>();
		//用接口接收接口实现类的new对象
		list.add("c");
		list.add("a");
		list.add("b");
		list.add("d");
		list.add("d");
		System.out.println(list);
		System.out.println(list.get(2));
		list.add(1,"f");
		System.out.println(list);
		List<String> l = new ArrayList<String>();
		l.add("111");
		l.add("221");
		list.addAll(2, l);
		System.out.println(list);
		System.out.println(list.indexOf("111"));
		System.out.println(list.lastIndexOf("d"));
		list.remove(2);
		System.out.println(list);
		list.set(1, "1");
		System.out.println(list);
		List<String> sublist = list.subList(2, 5);
		//下标2-5
		System.out.println(sublist);
		int i = list.size();
		System.out.println(i);
	}
}

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

public class Test6 {
       public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("b");
		list.add("cd");
		list.add("qq");
		list.add("1");
		System.out.println(list);
		Collections.reverse(list);//反转list集合
		System.out.println(list);
		Collections.shuffle(list);//随机排序
		System.out.println(list);
		Collections.sort(list);//字典升序排列
		System.out.println(list);
    	   Person p1 = new Person("张三",22);
    	   Person p2 = new Person("李四",12);
    	   Person p3 = new Person("王五",30);
    	   Person p4 = new Person("qq",18);
    	   List<Person> p = new ArrayList<Person>();
    	   p.add(p1);
    	   p.add(p2);
    	   p.add(p3);
    	   p.add(p4);
    	   for(Person per : p){
    		   System.out.println(per.name +"   "+per.age);
    	   }
	}
}
class Person implements Comparator<Person>{
    String name;
    int age;
    public Person(){
    	
    }
    public Person(String name,int age){
    	this.name = name;
    	this.age = age;
    }
	@Override
	public int compare(Person o1, Person o2) {
		if(o1.age > o2.age)return 1;
		else if (o1.age < o2.age)return -1;
		else return 0;
	}
}

4.Map集合

Map用于保存具有映射关系的数据，因此集合中保存着两组值，一组用来保存Map里的key值，另一组保存Map中的value值；这两组都可以是任何引用类型的数据；
Map中的key值不允许重复，即同一个Map对象的任何两个Key通过equals方法比较都返回false；
Key和value之间存在单向一对一关系，即通过指定的key总能找到唯一确定的value；
TreeMap

//TreeMap的自然排序是字典排序
    	Map<Integer,String> map = new TreeMap<Integer,String>();
    	map.put(4, "a");
    	map.put(2, "a");
    	map.put(3, "a");
    	map.put(1, "a");
    	System.out.println(map);
    	Map<String,String> map1 = new TreeMap<String,String>();
    	map1.put("a", "a");
    	map1.put("c", "c");
    	map1.put("d", "d");
    	map1.put("b", "c");
    	map1.put("1", "1");
    	map1.put("11", "a");
    	System.out.println(map1);

HashMap

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

public class Test5 {
       public static void main(String[] args) {
    	Map<String,Integer> map = new HashMap<String,Integer>();
		//使用接口接受实现接口的HashMap类创建的对象
		map.put("a", 1);
		map.put("b", 1);
		map.put("c", 2);
		map.put("d", 3);
		System.out.println(map);
		System.out.println(map.get("c"));
		//根据key取值
		map.remove("a");
		System.out.println(map);
		//根据key移除键值对
		System.out.println(map.size());
		//输出集合长度
		System.out.println(map.containsKey("d"));
		System.out.println(map.containsValue(0));
		//分别根据key和value判断是否包含值
        //通过map.keySet()遍历map集合
		Set<String> keys = map.keySet();
		//map.keySet()获取整个key集合，赋值给keys
		for(String key : keys){
			System.out.println("key:" + key + " value:" + map.get(key));
		}
		//通过map.entrySet()遍历map集合
		Set<Entry<String, Integer>> entrys = map.entrySet();
		//需要import java.util.Map.Entry;
		for(Entry<String, Integer> en : entrys){
			System.out.println("key:" + en.getKey() + " value:" + en.getValue());
		}
	}
}