集合（有时候，代码比文字更直观！！！）

最新推荐文章于 2024-06-14 15:02:13 发布

愿不知曲中意

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量110

点赞数

分类专栏：学习的旅途文章标签： java

本文链接：https://blog.csdn.net/weixin_54588824/article/details/114898400

版权

学习的旅途专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一个合格的预备役程序员，要学会在代码中进行自我学习与理解（才不是我懒~）

1、集合与数组的区别

在这里插入图片描述

2、集合框架

在这里插入图片描述

3、ArrayList

import java.util.ArrayList;

public class Test2 {

	public static void main(String[] args) {
		// Object->Collection->List->ArrayList
		ArrayList arrayList = new ArrayList();
		System.out.println(arrayList.isEmpty());// 判断是否为空
		arrayList.add("abc");
		arrayList.add("xyz");
		int size = arrayList.size();// 获取元素个数
		System.out.println(size);
		System.out.println(arrayList.isEmpty());
		arrayList.clear();// 清除所有元素
		System.out.println(arrayList.isEmpty());
		System.out.println("-----------------------");
		ArrayList arrayList2 = new ArrayList();
		arrayList2.add(0,"ab");// 在指定位置添加元素
		System.out.println(arrayList2.size());
		arrayList2.add(1,"cd");
		System.out.println(arrayList2.size());
		System.out.println("-----------------------");
		// 相同位置，后添加的会占据该位置，
		// 而前面添加在该位置的元素及其后面的元素会向后一位
		arrayList2.add(0,"mn");
		Object object = arrayList2.get(0);// 获取指定位置的元素
		System.out.println(object);
		object = arrayList2.get(1);
		System.out.println(object);
		object = arrayList2.get(2);
		System.out.println(object);
		arrayList2.add("mn");// 元素可重复
		object = arrayList2.get(3);
		System.out.println(object);
		System.out.println("-----------------------");
		// 列表的循环
		int size2 = arrayList2.size();
		for (int i = 0; i < size2; i++) {
			Object obj = arrayList2.get(i);
			System.out.println(obj);
		}
		System.out.println("-----------------------");
		ArrayList arrayList3 = new ArrayList();
		arrayList3.add("mm");
		arrayList3.add("mb");
		arrayList3.add("mh");
		arrayList3.add("mj");
		arrayList2.addAll(arrayList3);// 添加所有元素
		size2 = arrayList2.size();
		for (int i = 0; i < size2; i++) {
			Object obj = arrayList2.get(i);
			System.out.println(obj);
		}
		System.out.println("-----------------------");
		// 是否包含
		boolean contains = arrayList2.contains("ma");
		System.out.println(contains);
		System.out.println("-----------------------");
		// 最后一次出现索引
		System.out.println(arrayList2.lastIndexOf("mn"));
		System.out.println("-----------------------");
		// 删除
		arrayList2.remove("ab");
		System.out.println(arrayList2.size());
		System.out.println(arrayList2.lastIndexOf("ab"));
		System.out.println("-----------------------");
		size2 = arrayList2.size();
		for (int i = 0; i < size2; i++) {
			Object obj = arrayList2.get(i);
			System.out.println(obj);
		}
		System.out.println("-----------------------");
		// 替换指定位置的元素
		arrayList2.set(0, "00");
		size2 = arrayList2.size();
		for (int i = 0; i < size2; i++) {
			Object obj = arrayList2.get(i);
			System.out.println(obj);
		}
		System.out.println("-----------------------");
		// 转成数组
		Object[] array = arrayList2.toArray();
		for (Object object2 : array) {
			System.out.println(object2);
		}
	}
}

3.1、迭代器

import java.util.ArrayList;
import java.util.Iterator;

public class Test6 {

	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("abc");
		arrayList.add("xyz");
		arrayList.add("czd");
		
		// 迭代器
		Iterator<String> iterator = arrayList.iterator();
		while(iterator.hasNext()) {
			String next = iterator.next();
			System.out.println(next);
			// 不能在遍历过程中对原有集合进行修改
			// arrayList.add("ghs");
			// java.util.ConcurrentModificationException 并发修改异常
		}
		
//		Iterator<String> iterator = arrayList.iterator();
//		boolean hasNext = iterator.hasNext();
//		if(hasNext) {
//			String next = iterator.next();
//			System.out.println(next);
//		}
//		hasNext = iterator.hasNext();
//		if(hasNext) {
//			String next = iterator.next();
//			System.out.println(next);
//		}
//		hasNext = iterator.hasNext();
//		if(hasNext) {
//			String next = iterator.next();
//			System.out.println(next);
//		}
//		hasNext = iterator.hasNext();
//		if(hasNext) {
//			String next = iterator.next();
//			System.out.println(next);
//		}	
	}
}

注意：
1.若迭代器已经指向集合的末尾，如果再调用next()会返回NoSuchElementException异常；
2.在调用remove之前没有调用next是不合法的，会抛出IllegalStateException异常。

3.2、趣味题（不能重复输入）

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

public class Test1 {

	public static void main(String[] args) {
		// 不能重复输入
		ArrayList<String> arrayList = new ArrayList<>();
		putElementToList1(arrayList, "abc");
		putElementToList1(arrayList, "abm");
		putElementToList1(arrayList, "abc");
		System.out.println(Arrays.toString(arrayList.toArray()));
		putElementToList2(arrayList, "abd");
		putElementToList2(arrayList, "abd");
		System.out.println(Arrays.toString(arrayList.toArray()));
		putElementToList3(arrayList, "gfd");
		putElementToList3(arrayList, "abm");
		System.out.println(Arrays.toString(arrayList.toArray()));
	}
	public static void putElementToList1(ArrayList<String> list,String element) {
		boolean isContsins = false;
		for (int i = 0; i < list.size(); i++) {
			String str = list.get(i);
			if (str.equals(element)) {
				isContsins = true;
				break;
			}
		}
		if(!isContsins) {
			list.add(element);
		}
	}
	public static void putElementToList2(ArrayList<String> list,String element) {
		boolean contains = list.contains(element);
		if(!contains) {
			list.add(element);
		}
	}
	public static void putElementToList3(ArrayList<String> list,String element) {
		int index = list.indexOf(element);
		if(!(index>=0)) {// index>=0表示集合存在该元素
			list.add(element);
		}
	}
}

4、泛型

把原来程序运行时可能发生的问题转变为编译时的问题
格式：集合类<类的类型> 变量名 = new 集合类<类的类型>();

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

//public class Test7<T>  泛型类
public class Test7 {

	public static void main(String[] args) {
		// 泛型
		Test7 demo=new Test7();
		demo.printData(3);
		demo.printData("g");
		demo.printData(new Object());
		// 向下限定
		Collection<? extends Animal> collection1 = new ArrayList<Dog>();
		Collection<? extends Animal> collection2 = new ArrayList<Animal>();
		// 向上限定
		Collection<? super Animal> collection3 = new ArrayList<Object>();
		Collection<? super Animal> collection4 = new ArrayList<Animal>();
		// 无限定
		Collection<?> collection5 = new ArrayList<Object>();
		Collection<?> collection6 = new ArrayList<Animal>();
		Collection<?> collection7 = new ArrayList<Dog>();
	}
//public void printData(T[] data)
	public<T> void printData(T data) {
		System.out.println(data);
	}
}

5、Set

Set中的元素是无序存放的，即元素存入和取出的顺序不一定相同，且元素不能重复。
特点：
Set中的元素无序，但可以排序；
Set中的元素无下标；
Set中的元素不可重复。

5.1、HashSet

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

public class Test3 {

	public static void main(String[] args) {
		// hashset：无序、没有下标、元素不可重复、存入与输出顺序不一的相同
		HashSet<String> hashSet = new HashSet<>();
		System.out.println(hashSet.isEmpty());// 判断是否为空
		hashSet.add("asd");// 添加元素
		hashSet.add("add");
		hashSet.add("bgr");
		int size = hashSet.size();// 元素个数
		System.out.println(size);
		// 迭代器  ps：hashset因为无序、无下标，所以不能用for循环
		Iterator<String> iterator = hashSet.iterator();
		while(iterator.hasNext()) {
			String next = iterator.next();
			System.out.println(next);
		}
		// 判断是否包含
		boolean contains = hashSet.contains("fgn");
		System.out.println(contains);
//		hashSet.clear();// 删除所有元素
//		System.out.println(hashSet.isEmpty());// 输出的是true
		hashSet.remove("asd");// 删除指定元素
		System.out.println(hashSet.size());
	}
}

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

public class Test4 {

	public static void main(String[] args) {
		HashSet<Student> hashSet = new HashSet<>();
		Student student1 = new Student("zxx",20);
		Student student2 = new Student("zmy",21);
		Student student3 = new Student("lqx",19);
		Student student4 = new Student("zxx",20);
		hashSet.add(student1);
		hashSet.add(student2);
		hashSet.add(student3);
		hashSet.add(student4);
		System.out.println(hashSet.size());
		
		// 元素不可重复，student1和student4虽然看起来相同，
		// 但是它们是不同的对象，所以student4能够存入
		// ps：若重写hashCode和equals，那么student4就不能存入
		System.out.println(student1.equals(student4));
		
		Iterator<Student> iterator = hashSet.iterator();
		while(iterator.hasNext()) {
			Student student = iterator.next();
			System.out.println(student);
		}
	}
}

5.2、TreeSet

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

public class Test5 {

	public static void main(String[] args) {
		// 存储有序，但是没有下标
		TreeSet<String> treeSet = new TreeSet<>();
		treeSet.add("zxx");// 添加元素
		treeSet.add("zmy");
		treeSet.add("abc");
		// 元素不能重复
		treeSet.add("abc");
		System.out.println("-----");
		//输出set中大于等于给定元素的最小元素，不存在输出null
		System.out.println(treeSet.ceiling("zxy"));
		System.out.println("-----");
		// 迭代器
		Iterator<String> iterator = treeSet.iterator();
		while(iterator.hasNext()) {
			String next = iterator.next();
			// 按字典顺序排序输出 compareTo
			System.out.println(next);
		}
		System.out.println(treeSet.size());// 元素个数
	}
}

5.2.1 趣味题（按年龄/名字排序）

// 所有加入TreeSet的元素必须实现Comparable（排序接口）接口
// Comparable只有一个方法compareTo（大于返回整数，小于返回负数，等于返回零）
public class Student implements Comparable<Student>{
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Student student) {
		// 按年龄从小到大排序，若返回值交换则从大到小排序
		if(this.age > student.age) {
			return 1;
		}
		if(this.age < student.age) {
			return -1;
		}
		// 保证年龄相同的情况下名字按字典顺序输出，而不是当做重复元素禁止存入
//		String name1 = this.name;
//		String name2 = student.name;
//		if(name1.compareTo(name2)>0) {
//			return 1;
//		}
//		if(name1.compareTo(name2)<0) {
//			return -1;
//		}
//		if(name1.compareTo(name2)==0) {
//			return 0;
//		}
		return this.name.compareTo(student.name);
	}	
}

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

public class Test1 {

	public static void main(String[] args) {
		// Student类实现接口Comparable（排序接口），对compareTo方法进行了重写
		TreeSet<Student> treeSet = new TreeSet<>();
		Student student1 = new Student("zxx",20);
		Student student2 = new Student("zmy",21);
		Student student3 = new Student("lqx",19);
		Student student4 = new Student("wmd",20);
		treeSet.add(student1);
		treeSet.add(student2);
		treeSet.add(student3);
		treeSet.add(student4);
		Iterator<Student> iterator = treeSet.iterator();
		while(iterator.hasNext()) {
			Student student = iterator.next();
			System.out.println(student);
		}		
	}
}

6、Map

特点：
采用key-value的形式存储数据；
Map中key不可重复；
各个键值对无序；
各个键值对无下标。

6.1、Map与Collection比较

1.Map与Collection是并列存在的，互相没有继承关系！！！（关于这一点我有发言权，差点没把老师气昏过去）；
2.Map存储单位是key/value对，Collection存储单位是单个对象；
3.Map存储元素是put方法，Collection存储元素是add方法；
4.Map集合没有直接迭代的方法，而是先转成Set集合，再通过迭代获取元素；
5.Map集合中key要保证唯一性，所有key组成一个Set集合。

6.2、HashMap

import java.util.HashMap;

public class Test1 {

	public static void main(String[] args) {
		HashMap<String,String> hashMap = new HashMap<String,String>();
		boolean empty = hashMap.isEmpty();
		System.out.println(empty);
		System.out.println("----------");
		hashMap.put("zs", "542888");
		hashMap.put("ls", "545687");
		hashMap.put("ww", "557684");
		empty = hashMap.isEmpty();
		System.out.println(empty);
		int size = hashMap.size();// 键-值映射关系数
		System.out.println(size);
		System.out.println("----------");
//		hashMap.clear();// 清除所有映射关系
//		 size = hashMap.size();
//		System.out.println(size);
		boolean containsKey = hashMap.containsKey("zl");
		System.out.println(containsKey);// 是否包含指定键的映射关系
		boolean containsValue = hashMap.containsValue("545687");
		System.out.println(containsValue);// 是否包含指定值的映射关系
		System.out.println("----------");
		String string = hashMap.get("ww");// 依据键获得value值
		System.out.println(string);
		System.out.println("----------");
		hashMap.remove("zs");// 移除指定键以及相应的value值
		size = hashMap.size();
		System.out.println(size);
	}
}

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

public class Test2 {

	public static void main(String[] args) {
		HashMap<String,String> hashMap = new HashMap<String,String>();
		hashMap.put("zs", "542888");
		hashMap.put("ls", "545687");
		hashMap.put("ww", "557684");
//		hashMap.put("zs", "999999");
//		System.out.println(hashMap.size());
//		System.out.println(hashMap.get("zs"));
		// 遍历hashMap
		// keySet()：返回此映射中所包含的键的 Set 视图
		//                                   实现Set接口的对象
		Set<String> keySet = hashMap.keySet();
		System.out.println(keySet);
		Iterator<String> iterator = keySet.iterator();
		while(iterator.hasNext()) {
			String key = iterator.next();
			String value = hashMap.get(key);
			System.out.println(key+"="+value);
		}		
	}
}

愿不知曲中意

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合（有时候，代码比文字更直观！！！）

一个合格的预备役程序员，要学会在代码中进行自我学习与理解（才不是我懒~）目录1、集合与数组的区别2、集合框架3、ArrayList3.1、迭代器3.2、趣味题（不能重复输入）4、泛型5、Set5.1、HashSet5.2、TreeSet5.2.1 趣味题（按年龄/名字排序）6、Map6.1、Map与Collection比较6.2、HashMap1、集合与数组的区别2、集合框架3、ArrayListimport java.util.ArrayList;public class Test2
复制链接

扫一扫