java集合概述

奋死学习Java 29天前 ⋅ 125 阅读

Java集合概述

Java集合类存放于java.util包中,是一个用来存放对象的容器。

  • 集合只能存放对象。比如存一个int型数据1放入集合中,他会自动转换成Integer类后存入。
  • 集合存放的是多个对象的引用,对象本身还是放在堆内存中。
  • 集合可以存放不同类型,不限数量的数据类型。

Java集合可分为Set(无序、不可重复)、List(有序、可重复)、Map(具有映射关系的集合)

 

Set

HashSet是Set接口的典型实现,大多数时候使用Set集合时都使用这个实现类。他具有以下特点:

  1. 不能保证元素的排列顺序
  2. 不可重复
  3. HashSet不是线程安全的
  4. 集合元素可以是null

HashSet的使用方法

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

public class Test4 {
	public static void main(String[] args) {
		Set set = new HashSet();//创建一个set对象,Java的集合类中只能存放对象
		set.add(1);//add的用法就是添加 这样Set类里
		set.add("a");
		System.out.println(set);//输出结果  [1, a]		
		set.remove(1);//移除数据
		System.out.println(set);//输出结果为  [a]
		
		set.contains("a");//判断列表里有没有这个值
		System.out.println(set.contains("a"));//输出结果为   true
		
		set.clear();//清空集合元素
		System.out.println(set);//输出结果为  []
	}
}

HashSet遍历集合的两种方法

package day;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test4 {
	public static void main(String[] args) {
		Set set = new HashSet();//创建一个set对象,Java的集合类中只能存放对象
		
		set.add("a");
		set.add("b");
		set.add("c");
		set.add("d");//添加元素
  
          set.add(null);//还可以存null,但只能存一个null
          set.add(true);//可以存true 或 false的布尔类型
		
		System.out.println(set);//输出结果 [d, b, c, a]  set集合是无序性 也是不重复的 比如有两个a
   那么它只会记一个a
		//用迭代器遍历集合
		Iterator it = set.iterator();
		
		while (it.hasNext()) {   //当有next 那么我们对它输出
		System.out.println(it.next());//输出 d b c a
			
		}
		
		//for each 迭代集合  一般都取这种方法
		
		for (Object obj : set) { //把set的每一个值取出来赋值给obj,直到循环set的所有值
			System.out.println(obj);//输出 d b c a
		}
              System.out.println(set.size());//获取集合的元素个数  //4
          
          //如果想要集合只能存同样类型的对象怎么做
		//就要使用泛型,怎么使用呢?
		Set<String> set1 = new HashSet<>();//这就是指定泛型,只能填string类型,当然也可以变成别的类型
		set1.add("abc");//指定了是String类型就不能再填别的了。
		  //如果想任何类型的都可以那应该怎么弄呢?,可以指定为object类
		Set<Object> set3 = new HashSet<>();//因为object类是所有类的父类
	}
}

TreeSet自然排序

TreeSet会调用集合元素的compare To(Object obj)方法来基表元素之间的大小关系,然后将集合元素按升序排列。

  • 如果this>obj,返回正数1
  • 如果this<obj,返回负数-1
  • 如果this=obj,返回0,且认为这两个对象相等
  • 必须放入同样类的对象,(默认会进行排序)否则可能会发生类型转换异常。我们可以使用泛型来进行限制

下面是TreeSet的几种使用方法以及遍历集合

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

public class Test04 {
	public static void main(String[] args) {
		Set<Integer> set = new TreeSet<>();
		
		set.add(5);
		set.add(2);
		set.add(4);
		set.add(3);//添加集合元素
		System.out.println(set);//这就是TreeSet的自然排序
          set.remove(2);//移除集合元素2
		//set.clear();清空集合
		set.contains(4);//判断集合是否有元素4
		
		Iterator<Integer> it = set.iterator();//使用迭代器遍历集合
		while (it.hasNext()) {
			System.out.println(it.next());
			
		}
		
		for(Integer i : set){//使用 for each遍历集合
			System.out.println(i);
		}
		System.out.println(set.size());
	}
}

用TreeSet给人按年龄升序排列 

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

public class Test04 {
	public static void main(String[] args) {
	
		
		Person p1 = new Person("张三",23);
		Person p2 = new Person("李四",20);
		Person p3 = new Person("王五",16);
		Person p4 = new Person("Lcuy",29);//new四个对象
		
		Set<Person> set1 = new TreeSet<Person>(new Person());//创建个集合来装对象
		set1.add(p1);
		set1.add(p2);
		set1.add(p3);
		set1.add(p4);//将对象装进集合
		//通过for each 遍历集合
		for (Person p : set1) {
			System.out.println(p.name+""+p.age);
                   //输出结果    王五16 李四20 张三23  Lcuy29
		}
	}
}
class Person implements Comparator<Person>{//实现接口
	int age;
	String name;//根据年龄把person对象存到TreeSet中并按年龄排序
	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;
		}
		
	}
}

List

下面是关于List和ArrayList的使用方法

import java.util.List;//这是util. 看清楚
import java.util.ArrayList;

public class Test6 {//List允许使用重复元素,且有序 
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("b");//第一个索引下标0
		list.add("d");//1
		list.add("c");//2
		list.add("a");//3
		System.out.println(list.get(2));//通过索引下标访问指定位置的集合元素
		System.out.println(list);
		
		list.add(1,"f");//在指定索引下标的位置插入数据
		
		List<String> l = new ArrayList<>();
		l.add("123");//向集合里添加元素
		l.add("456");
		
		list.addAll(2,l);//在list集合索引下标为2 的位置插入集合l
		
		System.out.println(list);
          	list.add(1,"f");//在指定索引下标的位置插入数据
		
		List<String> l = new ArrayList<>();
		
		System.out.println(list.indexOf("d"));//获取指定元素在集合中第一次出现的索引下标
		System.out.println(list.lastIndexOf("d")); //获取指定元素在集合中最后一次出现的下标
		
		list.remove(2);//根据指定的索引下标移除元素
		System.out.println(list);
		
		list.set(1,"ff");//根据指定索引下标修改元素
		System.out.println(list);

Map

Map接口储存一组成对的键-值对象,提供key(键)到value(值)的映射,Map中的key不要求有序,不允许重复。value同样不要求有序,但可以重复。最常见的Map实现类是HashMap

下面是关于HashMap的几种使用方法:

import java.security.KeyStore.Entry;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test06 {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("b", 1);
		map.put("c", 2);
		map.put("e", 3);//map是无序的
		System.out.println(map);
		System.out.println(map.get("e"));//根据key取值
		
		map.remove("c");//根据key移除键值对
		System.out.println(map.size());//map的长度
		
		System.out.println(map.containsKey("e"));//判断集合是否包含指定的key
		
		System.out.println(map.containsValue(2));//判断集合是否包含指定的value
		
		//map.clear();清空集合
		
		Set<String> keys = map.keySet();//可以获取map集合的key的集合
		
		map.values();//获取map集合的value值
		
		//遍历map
		for (String key : keys) {
			System.out.println("key: "+key+",value: "+map.get(key));
			
		}
		//通过map.entrySet();遍历集合
		Set<Map.Entry<String, Integer>> entrys = map.entrySet();
		for(Map.Entry<String, Integer> en : entrys){
			System.out.println("key: "+en.getKey()+",value: "+en.getValue()));
		}
	}
}
输出结果
{e=3, b=1, c=2}
3
2
true
false
key: e,value: 3
key: b,value: 1
key: e,value: 3
key: b,value: 1
{1=a, 2=a, 3=a, 4=a}
{1=ab, 10=ab, ab=ab, b=b, c=c, d=d}

TreeMap

TreeMap可以保证所有的Key-Value对处于有序状态。自然排序中,TreeMap的所有的Key必须实现Comparable接口,而且所有的Key应该是同一个类的对象,否则将会抛出ClassCastException错误。

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

public class Test06 {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("b", 1);
		map.put("c", 2);
		map.put("e", 3);//map是无序的
		System.out.println(map);
		System.out.println(map.get("e"));//根据key取值
		
		map.remove("c");//根据key移除键值对
		System.out.println(map.size());//map的长度
		
		System.out.println(map.containsKey("e"));//判断集合是否包含指定的key
		
		System.out.println(map.containsValue(2));//判断集合是否包含指定的value
		
		//map.clear();清空集合
		
		Set<String> keys = map.keySet();//可以获取map集合的key的集合
		
		map.values();//获取map集合的value值
		
		//遍历map
		for (String key : keys) {
			System.out.println("key: "+key+",value: "+map.get(key));
			
		}
		//通过map.entrySet();
		Set<Map.Entry<String, Integer>> entrys = map.entrySet();
		for(Map.Entry<String, Integer> en : entrys){
			System.out.println("key: "+en.getKey()+",value: "+en.getValue());
		}
		Map<Integer, String> map1 = new TreeMap<>();
		map1.put(4, "a");
		map1.put(2, "a");
		map1.put(3, "a");
		map1.put(1, "a");
		System.out.println(map1);
		
		Map<String, String> map2 = new TreeMap<>();
		map2.put("b", "b");
		map2.put("c", "c");
		map2.put("d", "d");
		map2.put("ab", "ab");
		map2.put("1", "ab");
		map2.put("10", "ab");
		
		System.out.println(map2);//英文字典排序
		
	}
}

输出结果
{e=3, b=1, c=2}
3
2
true
false
key: e,value: 3
key: b,value: 1
key: e,value: 3
key: b,value: 1
{1=a, 2=a, 3=a, 4=a}
{1=ab, 10=ab, ab=ab, b=b, c=c, d=d}

操作集合的工具类Collections

Collections类是Java提供的一个操作Set、List和Map等集合的工具类。Collections类提供了许多操作集合的静态方法,借住这些静态方法可以实现集合元素的排序、查找替换和复制等操作。

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

public class Test7 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("b");
		list.add("cd");
		list.add("ca");
		list.add("a");
		list.add("l");//给list集合添加元素
		
		System.out.println(list);
		
		Collections.reverse(list);//反转list中元素的性质
		System.out.println(list);
		
		Collections.shuffle(list);//对list进行随机排序
		System.out.println(list);
		
		Collections.sort(list);//字典方式进行升序排列
		System.out.println(list);
  
           System.out.println(Collections.frequency(list, "a"));//指定list中a的出现次数
           Collections.replaceAll(list, "a", "aa");//将list中的a替换成aa
  
           Collections.swap(list, 0, 4);//第0个和第4个位置的元素替换
		
           System.out.println(Collections.max(list));//返回集合最大最小值
		System.out.println(Collections.min(list));
  
          //重写方法,按年龄升序排列
		Student s1 = new Student(14,"张三");
		Student s2 = new Student(12,"李四");
		Student s3 = new Student(13,"王五");
		Student s4 = new Student(11,"lucy");
		
		List<Student> stus = new ArrayList<>();
		stus.add(s1);
		stus.add(s2);
		stus.add(s3);
		stus.add(s4);
         
		for(Student stu : stus){
			System.out.println(stu.name + "," + stu.age);
		}
		
		System.out.println("---------------");//上下输出对比
  
  		Collections.sort(stus,new Student());
  
		//遍历集合,按年龄升序输出
		for(Student stu : stus){
			System.out.println(stu.name + "," + stu.age);
		}
	}
}
//Student类实现接口
class Student implements Comparator<Student>{
	int age;
	String name;
	public  Student() {
		
	}
	public  Student(int age, String name) {
		this.age = age;
		this.name = name;
	}
	
	@Override
	public int compare(Student o1, Student o2) {
		if(o1.age > o2.age){
			return 1;
		}else if (o1.age < o2.age) {
			return -1;
			
		}else {
			return 0;//根据年龄升序排列对象
		}
	}
	
	
}
输出列表
[b, cd, ca, a, l]
[l, a, ca, cd, b]
[b, cd, ca, l, a]
[a, b, ca, cd, l]
张三,14
李四,12
王五,13
lucy,11
---------------
lucy,11
李四,12
王五,13
张三,14

 

全部评论: 0

    我有话说: