java 集合补充

最新推荐文章于 2023-06-16 21:33:01 发布

旭辉lin

最新推荐文章于 2023-06-16 21:33:01 发布

阅读量397

点赞数

本文链接：https://blog.csdn.net/xuhui2218781388/article/details/39024489

版权

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

1 Map集合

Map集合：

Map和Collecton为同层次的接口，HashMap，TreeMap和Hashtable都是Map的直接子类。
Map顶层接口,该集合存储的是键值对,而且键是唯一的,Map和Set很像,Set集合底层就是使用了Map集合。
Map集合没有迭代器，要取出元素必须先将Map集合转换成Set集合才能遍历元素
|-->HashTable(JDK1.0): （基本上被HashMap所取代）
底层是哈希表数据结构，线程同步，效率低，不可以使用null键和null值。
用作键的对象必须实现hashCode和equals方法来保证键的唯一性
|-->HashMap(JDK1.2):
底层是哈希表数据结构，线程不同步，效率高，允许使用null键和null值。
保证元素唯一性的:
原理：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true
(往HashSet里面存的自定义元素要复写hashCode和equals方法，以保证元素的唯一性！)
|-->TreeMap(JDK1.0):
底层是二叉树结构，线程不同步，允许使用null键和null值；
可以给Map集合中的键进行排序.
1.TreeMap排序的第一种方式:让元素自身具备比较性，比如八种基本数据类型或则字符串，
实现Compareble接口,覆盖compareTo方法，此方式是元素的自然顺序
2. TreeMap排序的第二种方式:当元素自身不具备比较性(比如存储学生对象时)或者具备的
比较性不是我们所需要的(比如想字符串的长度排序),就需要让集合自身具备自定义的比较性。
定义一个类，实现Comparator接口，覆盖compare方法。
以下是Map的两种取出方式：
第一种：Set<K> keySet()
返回此映射中包含的键的Set视图，将Map集合中所有的键存入Set集合，然后再通过Set集合的
迭代器取出所有的键，再根据get方法获取每个键的值；
例如：

package map;

import java.util.*;

public class HashMapDemo1 {
	public static void main(String[] args) {
		Map<Student, String> hmap = new HashMap<Student, String>();// 这里用到了多态的概念
		hmap.put(new Student("001", 20), "beijing");// 将指定的值与此映射中的指定键关联
		hmap.put(new Student("002", 25), "hebei");
		hmap.put(new Student("003", 50), "hainan");
		hmap.put(new Student("001", 20), "beijing");
		System.out.println(hmap.size());// int size() 返回此映射中的键-值映射关系数。
		Set<Student> keySet = hmap.keySet();// 将Map集合中所有的键存入Set集合
		Iterator<Student> it = keySet.iterator();// 获取Set集合的迭代器
		while (it.hasNext()) { // 判断是否有下一个元素
			Student stu = it.next(); // 取出下一个元素
			String addr = hmap.get(stu);// 根据get方法获取每个键的值
			System.out.println(stu.getName() + ".." + stu.getAge() + "::"
					+ addr);// 获取键和值
		}
	}
}

class Student {
	private String name;
	private int age;

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

	public int getAge() {
		return age;
	}

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

	public String getName() {
		return name;
	}

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

	@Override
	// 覆写的标记 自定义元素要复写hashCode和equals方法
	public int hashCode() {// 对象实现hashCode和equals方法来保证键的唯一性
		return name.hashCode() + age * 34;
	}

	@Override
	// 覆写的标记
	public boolean equals(Object obj) {// 比较指定对象与此项的相等性。
		if (!(obj instanceof Student))// 判断obj是不是Student对象类型
			return false;
		Student stu = (Student) obj;
		return this.name.equals(stu.name) && this.age == stu.age;
	}
}

第二种：Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的Set视图，将Map集合中的映射关系存入到Set集合中，这个映射关系的数据类型是Map.entry,再通过Map.Entry类的方法再要取出关系里面的键和值。

Entry其实就是Map中的一个static内部接口。

为什么要定义在内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。

关系属于Map集合中的一个内部事物。

而且该事物在直接访问Map集合中的元素。

keySet取出所有V值原理：利用keySet（）方法，将所有的key值存储到一个set集合中，然后通过set集合中的迭代器以及map中get（key）方法获取相应的值

entryset的原理：

调用Entryset（）方法，这个方法返回值类型是set类型的Map.Entry<k,v>（这是一个接口）。Map.Entry<k,v>反映到set中是一个连在一体的键值对。如果想取出其中的key和value就使用Map.Entry中getKey和getValue方法来获取相应的键和值。

Map.Entry，Entry也是一个接口，他是map接口中的一个内部接口。

interface Map

{

public static interface Entry//接口中定义了一个内部接口

{//为什么要定义在内部？因为这个Entry首先是一个映射关系，属于Map

public abstract Object getKey();//封装了2个方法

public abstract Object getValue();

}

子类实现这个接口就可以了。如HashMap

class HashMapimplements Map

{

class Hahs implements Map.Entry//定义内部类，这样来实现Entry

{

public Object getKey(){}

public Object getValue(){}

}

使用例子：

package map;

import java.util.*;

class Student1 implements Comparable<Student1> {// 实现Compareble接口
	private String name;
	private int age;

	public Student1(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 String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int hashCode() {// 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) {// 对象实现hashCode和equals方法来保证键的唯一性
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())// obj.getClass()获得obj的字节码对象
			return false;
		Student1 other = (Student1) 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 int compareTo(Student1 o) {// 覆盖compareTo方法
		int num = new Integer(this.age).compareTo(new Integer(o.age));
		if (num == 0) {
			return this.name.compareTo(o.name);
		}
		return num;
	}
}

class StuNameComparator implements Comparator<Student1> {// 实现Comparator接口
	@Override
	public int compare(Student1 o1, Student1 o2) {// 覆盖compare方法。
		int num = o1.getName().compareTo(o2.getName());
		if (num == 0) {
			return new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));
		}
		return num;
	}
}

public class TreeMapDe {
	public static void main(String[] args) {
		TreeMap<Student1, String> treemap = new TreeMap<Student1, String>(
				new StuNameComparator());
		treemap.put(new Student1("aligui", 44), "shanghai");// 将指定的值与此映射中的指定键关联
		treemap.put(new Student1("bwanggui", 24), "tanjin");
		treemap.put(new Student1("csungui", 35), "22222222222");
		Set<Map.Entry<Student1, String>> entrySet = treemap.entrySet();// Map集合中的映射关系存入到Set集合中
		Iterator<Map.Entry<Student1, String>> it = entrySet.iterator();
		while (it.hasNext()) {
			// Map.Entry类的方法再要取出关系里面的键和值
			Map.Entry<Student1, String> mapEntry = it.next();
			// Student student=(Student)key;
			System.out.print(mapEntry.getKey());// K getKey() 返回与此项对应的键。
			System.out.println(mapEntry.getValue());// V getValue() 返回与此项对应的值。
		}
	}
}

集合经典运用：

查询一段字母串中各个字母的的个数

第一次用a字母作为键去找集合，那么集合没有a这么键，所以没有对应的次数，返回null

如果为null，那么就将a和1存入集合。

如果指定的键已经存在，说明有对应的次数。就将对应的次数取出，并自增后重新存入集合。

思路：

1，将字符串转换成字符数组。因为要对每一个字母进行操作。

2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。

3，遍历字符数组。

将每一个字母作为键去查map集合。

如果返回null，将该字母和1存入到map集合中。

如果返回不是null，说明该字母在map集合已经存在并有对应次数。

那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。

4，将map集合中的数据变成指定的字符串形式返回。

示例：

package map;

import java.util.TreeMap;
import java.util.Iterator;
import java.util.Set;

public class TreeMapTest {
	public static void main(String[] args) {
		getCount("ssdfghytrerssav");
	}

	// 统计字母出现次数的方法，传递一个字符串进来
	private static void getCount(String str) {
		if ("".equals(str)) {
			System.out.println("字符串为空");
			return;
		}
		if (str == null) {
			throw new IllegalArgumentException("请传递字符串");
		}
		// 将字符串转成字符数组
		char[] ch = str.toCharArray();
		TreeMap<Character, Integer> tm = new TreeMap<>();
		// 遍历数组
		for (int x = 0; x < ch.length; x++) {
			Integer i = tm.get(ch[x]);
			if (i == null) {
				tm.put(ch[x], 1);
			} else if (i != null) {
				tm.put(ch[x], ++i);
			}
		}
		// 迭代这个集合，对结果详细的打印
		Set<Character> set = tm.keySet();
		Iterator<Character> it = set.iterator();
		while (it.hasNext()) {
			Character c = it.next();
			Integer i = tm.get(c);
			System.out.println(c + "出现了 " + i + " 次");
		}
	}
}

Map集合总结：
|--Hashtable 底层是哈希表结构线程安全的，并且键和值不能为null。
|--HashMap 底层是哈希表结构线程不安全的，键和值可以为null。
|--LinkedHashMap 底层是链表和哈希表线程不安全
|--TreeMap 底层是二叉树线程不安全的，键和值可以为null。
Map集合和Collection集合的区别？
Map中一次存储是键值对。
Collection中一次存储是单个元素。
Map的存储使用的put方法。
Collection存储使用的是add方法。
Map集合没有迭代器，Map的取出，是将Map转成Set，在使用迭代器取出。
Collection取出，使用就是迭代器。
如果对象很多，必须使用集合存储。
如果元素存在着映射关系，可以优先考虑使用Map存储或者用数组，
如果没有映射关系，可以使用Collection存储。

2 集合与数组互转

数组变集合：在java中可以将数组变成list集合。

把数组变成集合有什么优缺点呢？

主要优点是，可以使用集合的思想和方法来操作数组中的元素。将数组转换成集合的作用是可以限定对元素的操作，不需要增删

但是缺点是，将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。否者会包UnsupportedOperationException异常。

方法是：Arrays 的 asList()方法。

例如：

public static void arrayToList(){
String[] arr={"1","4","2","5","2"};

List<String> list=Arrays.asList(arr);

System.out.println(list); //输出list集合
System.out.println(list.contains("1")); //如果列表包含指定的元素，则返回 true。
System.out.println(list.set(1, "5")); // 用指定元素替换列表中指定位置的元素（可选操作）。
System.out.println(list.size());// 返回列表中的元素数。
System.out.println(list.subList(0,5)); // 返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图
System.out.println(list.get(2)); // 返回列表中指定位置的元素。
System.out.println(list.isEmpty()); // 如果列表不包含元素，则返回 true
System.out.println(list.toString()); //返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
System.out.println(list.indexOf("2")); // 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
System.out.println(list.get(2).equals("2")); //比较指定的对象与列表是否相等。
}

将数组变成集合还可以使用Collections中的静态方法。

要注意不可以使用集合的增删方法

注意点二：

public static void arrayToList(){
int[] arr={1,2,3,4,5};

List<int[]> list=Arrays.asList(arr);

System.out.println(list); //输出list集合

}

输出出的结果却是：[[I@1fb8ee3] 为什么不转成List集合呢？

原因是：如果数组的元素都是对象。那么变成集合时，数组中的元素就直接转换成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将数组作为集合中的元素存入。

这里只需要将基本数据类型改成他们的包装类即可。此处的int该为Integer。

集合变数组：

List集合中的toArray()方法。

那么指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于集合的size.那么该方法内部会创建一个新的数组。长度为集合的size.

当指定类型的数组长度大于了集合的size，就不会新创建数组。而是使用传递进来的数组。而传递进来的数组会空闲一部分存储空间

因此，创建一个刚刚好的数组最优。

例如：

public static void binarySearchDemo2(){
List<String> list =new ArrayList<String>();
list.add("ab");
list.add("gbd");
list.add("qdo");
list.add("wbdo");
list.add("wbdon");
String[] arr=list.toArray(new String[list.size()]); //创建一个刚刚好的数组最优。
}

总结：
A:该方法将一个数组变成集合后，不可以使用集合的增删方法，因为数组的长度是固定的！如果增删，则发生UnsupportedOprationException(不支持操作异常)
B:如果数组中的元素都是基本数据类型，则该数组变成集合时，会将该数组作为集合的一个元素出入集合
C:如果数组中的元素都是对象，如String，那么数组变成集合后，数组中的元素就直接转成集合中的元素
D:数组变集合以及集合变数组的对比
(1)数组变集合：
方法：static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。
好处：可以使用集合的思想和方法操作数组中的元素，数组是一个对象，但是数组中的功能很少
(2)集合变数组：
方法：Collction中的toArray方法
好处：可以限定对集合元素的操作，防止对集合的元素进行增删，因为数组长度是固定的。