15 集合

最新推荐文章于 2021-10-05 15:38:06 发布

勋大大

最新推荐文章于 2021-10-05 15:38:06 发布

阅读量134

点赞数 1

分类专栏： JAVA

本文链接：https://blog.csdn.net/weixin_44962092/article/details/95468098

版权

JAVA 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

集合

概述

变量：用一个变量去存储一个值
数组：用一个变量引用多个值   一旦定义  容量是固定的

用一些数据结构封装为一个单独的类 实现了数据的动态存储，叫做集合 集合是一个类

数组 集合区别：
	1）数组存储基本类型 集合存储Object类型
	2）数组长度固定 集合长度不固定
	3）数组只能存储相同类型 集合能存储任意类型

集合的体系

集合分类：
	单列集合：
		根接口是：Collection
		子接口：Queue  List Set
		实现类：ArrayList  Vector  LinkedList
	双列集合
		Map集合

Collection接口

特点：存储的数据类型是对象类型，是单列集合的根接口，没有实现类，其下有两个子接口List和Set,所以在Collection中定义的方法在它的子接口中也存在

方法：
- public boolean add(E e)：  把给定的对象添加到当前集合中 。
- public boolean add(Colllection c):将集合c中的元素添加到当前集合中。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e): 把给定的对象在当前集合中删除。
- public boolean removeAll(Colllection c): 从当前集合中删除c集合中的元素。
- public boolean contains(E e): 判断当前集合中是否包含给定的对象。
- public boolean containsAll(Colllection c): 判断c是否是当前集合的子集。
- public boolean isEmpty(): 判断当前集合是否为空。
- public int size(): 返回集合中元素的个数。
- public Object[] toArray(): 把集合中的元素，存储到数组中。

List子接口

特点：
	1.重复
	2.可以索引
	3.有序
注意：集合中所存放的数据都是Objec

List接口中的特有的方法（和下标有关的）

add（index,元素）
addAll(int index, Collection<? extends E> c) 
get(int index)
remove(int index)
set(int index, E element)
案例：
package cn.wzx;

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

public class Demo1 {
	public static void main(String[] args) {
		List list = new ArrayList();
		//add
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("胡哥");
		list.add("朱月");
		list.add("阿斯达");
		
		List  list2 = new ArrayList();
		list2.add("赵四");
		list2.add("刘能");
		
		//插入
		//list.add(1, "赵大帅");
		//list.addAll(list2);
		//list.addAll(1, list2);
		//System.out.println(list.get(1));
		//list.remove(5);
		list.set(5, "谢大脚");//修改集合中第几号元素
		
		//遍历
		Object[] array = list.toArray();
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}
}

List集合的遍历

1.for循环遍历
get（index）;//返回此列表中指定位置上的元素。

2.foreach遍历 增强for循环  和for循环没有任何关系 底层是迭代器实现的
for(元素类型的引用  ： 集合){
	
}

3.迭代器比较麻烦 一般不用


案例：
package cn.wzx;

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

public class Demo1 {
	public static void main(String[] args) {
		List list = new ArrayList();
		//add
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("胡哥");
		list.add("朱月");
		list.add("阿斯达");
		
		//1.for循环
		/*for (int i = 0; i <list.size(); i++) {
			System.out.println(list.get(i));
		}*/
		
		//2.
		/*for (Object object : list) {
			System.out.println(object);
		}*/
		//3.迭代器
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

List集合的实现类

ArrayList:底层是数组实现  线程不安全  效率高  查询快 增删慢
Vector: 底层数组实现  线程安全  效率低  出现的时间比 Collection  没人用
LinkedList:底层是用双向链表实现   增删块 查询慢

事实证明：
1.定义两个集合  
2.先为集合放同样的元素  在某个下标位置插入同等数量的元素
3.统计时间


案例：
package cn.wzx;

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

public class Demo2 {
	public static void main(String[] args) {
		List arrList = new ArrayList<>();
		List linkList = new LinkedList<>();
		
		//同时放入十万数据
		for (int i = 0; i < 100000; i++) {
			arrList.add(i);
			linkList.add(i);
		}
		
		
		//Arraylist 下标为50000 时间
		long start1 = System.nanoTime();
		System.out.println(arrList.get(50000));
		long end1 = System.nanoTime();
		long time1 = end1-start1;
		System.out.println("Array查询所有时间"+time1);
		
		//===========================================
		long start2 = System.nanoTime();
		System.out.println(linkList.get(50000));
		long end2 = System.nanoTime();
		long time2 = end2-start2;
		System.out.println("Link查询所有时间"+time2);
		
	}
}

实现类的底层实现

ArrayList:数组实现 查询快  增删慢  
LinkedList:双向链表实现  查询慢 增删快 当查询的时候 会进行一个加速操作 用要查询的元素下标和 集合的尺寸的二分之一进行比较 如果小于 集合.size()/2  从头查询

泛型

当一个集合中没有限定数据类型的时候，可以添加任何的数据，但是实际开发中需要对集合中的数据类型进行限定使用到了泛型 泛型可以限定集合中的数据类型 类中方法的参数类型 接口中的方法的参数类型
语法：
<泛型的符号>  E  T  V  
集合的泛型：

泛型类：（了解） 好处：可以增强方法的通用性
package cn.wzx;

public class Demo4 {
	public static void main(String[] args) {
		Test<String> test =new Test<>();
	}
}
class Test<T>{
	
	public void m(T t) {
		
	}
	
	public T m2() {
			
	}

}

泛型接口：好处：实现模版化编程（了解）
interface IA<E>{
	
	void m1(E e);
	E m2();
}
class Test1 implements IA<Student>{

	@Override
	public void m1(Student e) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public Student m2() {
		// TODO Auto-generated method stub
		return null;
	}
	
}

Collections工具类

数组：Array  工具类 Arrays
集合：Collection  工具类  Collections

案例：
package cn.wzx;

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

public class Demo5 {
	public static void main(String[] args) {
		/*List<String> strings = new ArrayList<>();
		
		strings.add("a");
		strings.add("b");
		strings.add("s");
		strings.add("z");
		strings.add("c");
		
		Collections.sort(strings);
		for (String string : strings) {
			System.out.println(string);
		}*/
		
		List<Worker> workers = new ArrayList<>();
		workers.add(new Worker("张三",17 ));
		workers.add(new Worker("李四",33 ));
		workers.add(new Worker("王五,12 ));
		workers.add(new Worker("大刀",56 ));
		workers.add(new Worker("小刀",67 ));
		
		//Collections.sort(workers);//排序
		//Collections.reverse(workers);//反转
		Collections.shuffle(workers);//随机显示
		for (Worker worker : workers) {
			System.out.println(worker);
		}
	}
}

class Worker implements Comparable<Worker>{
	String name;
	int age;
	public Worker() {
		super();
	}
	public Worker(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Worker [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Worker o) {
		// TODO Auto-generated method stub
		return this.age-o.age;
	}
}

Set集合

List集合：有序 可以重复 可以索引
Set集合：无序  不可重复  不可索引

Set集合的方法

只有从Collection接口中继承的方法
方法：
- public boolean add(E e)：  把给定的对象添加到当前集合中 。
- public boolean add(Colllection c):将集合c中的元素添加到当前集合中。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e): 把给定的对象在当前集合中删除。
- public boolean removeAll(Colllection c): 从当前集合中删除c集合中的元素。
- public boolean contains(E e): 判断当前集合中是否包含给定的对象。
- public boolean containsAll(Colllection c): 判断c是否是当前集合的子集。
- public boolean isEmpty(): 判断当前集合是否为空。
- public int size(): 返回集合中元素的个数。
- public Object[] toArray(): 把集合中的元素，存储到数组中。

实现类之HashSet

关于set集合去重
package cn.wzx;

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

public class Demo1 {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		
		//添加元素
		set.add("abc");
		set.add("dfg");
		set.add("sd");
		
		
		System.out.println(set.add("abcd"));
		Object[] array = set.toArray();
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
		System.out.println(set.size());
	}
}

Set集合的遍历

1.foreach遍历
package cn.wzx;

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

public class Demo1 {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		
		//添加元素
		set.add("abc");
		set.add("dfg");
		set.add("sd");
		set.add("sd");
		set.add("dfgag");
		set.add("swrtyd");

		//遍历
		for (String string : set) {
			System.out.println(string);
		}
	}
}

2.迭代器遍历
注意：在用迭代器和foreach遍历的时候 不能对集合的元素进行修改 否则会报错
foreach中可以使用 break 直接结束遍历 continue 也可以用
package cn.baizhi.day16;

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

public class Demo1 {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		
		//添加元素
		set.add("abc");
		set.add("dfg");
		set.add("sd");
		set.add("sd");
		set.add("dfgag");
		
		//遍历
		for (String string : set) {
			System.out.println(string);
			//set.add("asdfghj");
			if (string.equals("sd")) {
				break;
			}
			
		}
		Iterator<String> iterator = set.iterator();
		
		/*while (iterator.hasNext()) {
			System.out.println(iterator.next());
			//set.add("asdfghj");
		}*/
	}
}

HashSet集合的去重原理

Hashset集合的实现是一个数组链表，底层维护了一个数组，数组的每个元素的类型是一个链表（一个链表可以连接多个元素）

去重原理：
	1.一定让内容相同的对象返回相同的哈希码值，可能内容不同的对象的哈希码值也是相同的，通过hash值的换算将得出同一个下标位置，这时候将调用equals方法去判断这两个对象是否内容相同
	2.为了提高存储的效率优化存储空间 ，一定做到让内容相同的对象返回相同的hash值，尽可能让内容不同的对象返回不同的hash值

LinkedHashSet实现类

作用：LinkedHashSet 是HashSet的子类 也能去重 原理和HashSet一样，还能维护元素添加的顺序

TreeSet实现类

SortedSet的实现类 SortedSet是set的子接口
作用：去重  排序
去重原理：是根据比较规则去重的 当compareTo 方法返回0时 就认为这两个对象是同一个对象

Map集合

Map双列集合：Map集合中的元素是 key--value 形式存储

key:键  不可重复  无序  
value:值   可以重复的
key：value  -----   元素

HashMap实现类：
	key:是可以允许为null的
	value:可以为null
	线程不安全的 效率高
Hashtable实现类：
	key:不允许为null
	value：不允许为null
	线程安全 效率低 一般没人用  但是有面试题

如果所有的键所对应的值都相同  这个集合
HashSet的底层实现是HashMap 
	HashSet的实现是 键的类型是任意类型  但是值都为Object类型对象 new Object();

Map集合的遍历

1.通过keySet():可以将所有键获得放入到set集合中 ，遍历set集合 通过get(key)拿到值
package cn.wzx;

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

public class Demo3 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		//添加元素
		map.put(1, "李四");
		map.put(2, "吴昂无");
		map.put(3, "阿斯达");
		map.put(4, "张三");
		map.put(5, "刘能 ");
		map.put(6, "胡乱帅");
		
		//遍历
		Set<Integer> keySet = map.keySet();
		
		for (Integer key : keySet) {
			System.out.println(key+"----"+map.get(key));
		}
	}
}


2.将Map集合中的所有的值拿到放到一个集合中 遍历这个集合
package cn.wzx;

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

public class Demo3 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		//添加元素
		map.put(1, "李四");
		map.put(2, "吴昂无");
		map.put(3, "阿斯达");
		map.put(4, "张三");
		map.put(5, "刘能 ");
		map.put(6, "胡乱帅");
		
		//遍历
		/*Set<Integer> keySet = map.keySet();
		
		for (Integer key : keySet) {
			System.out.println(key+"----"+map.get(key));
		}*/
		
		Collection<String> values = map.values();
		
		for (String string : values) {
			System.out.println(string);
		}
	}
}


案例：通过输入值 找到集合中所对应的键
package cn.wzx;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Demo3 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		//添加元素
		map.put(1, "李四");
		map.put(2, "吴昂无");
		map.put(3, "阿斯达");
		map.put(4, "张三");
		map.put(5, "刘能 ");
		map.put(6, "胡乱帅");
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入值：");
		String nameString = scanner.next();
		
		Set<Integer> keySet = map.keySet();
		
		for (Integer integer : keySet) {
			if (map.get(integer).equals(nameString)) {
				System.out.println(integer);
			}
		}
	}
}

3.通过遍历键值对（了解）

案例：
package cn.wzx;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

public class Demo3 {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		//添加元素
		map.put(1, "李四");
		map.put(2, "吴昂无");
		map.put(3, "阿斯达");
		map.put(4, "张三");
		map.put(5, "刘能 ");
		map.put(6, "胡乱帅");
		Scanner scanner = new Scanner(System.in);
		
		Set<Entry<Integer, String>> entrySet = map.entrySet();
		for (Entry<Integer, String> entry : entrySet) {
           
			System.out.println(entry.getKey()+"  "+entry.getValue());
		}
		
	}
}

Map集合的其他实现类

LinkedHashMap<>()：能维护键值对添加的顺序 是HashMap的子类

TreeMap是SortedMap的实现类 SortedMap是Map的子接口，能够对键进行排序
注意：当键的类型是自定义对象的时候，如果要用treeMap进行排序必须重写comparable接口 定义比较规则

Properties：集合中的键和值都是String类型（jdbc struts2的配置文件）

案例：
package cn.wzx;

import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;



public class Demo3 {
	public static void main(String[] args) {
		Properties properties  = new Properties();
		
		properties.setProperty("1", "战三1");
		properties.setProperty("2", "战三2");
		properties.setProperty("3", "战三3");
		properties.setProperty("4", "战三4");
		properties.setProperty("8", "战三5");
		
		Set<Object> keySet = properties.keySet();
		
		for (Object object : keySet) {
			String string = (String)object;
			System.out.println(string+"---"+properties.getProperty(string));
		}
	}
}