miracle just wanna be better

集合

2019-07-15
miracle
Java

集合api:集合框架,把多个对象存储在一起,用集合的名称,并同时使用集合的api,来操作集合的数据
有了集合可以让数据的存储变得很复杂,用对象可以存储不同的数据类型的数据,把若干对象存储在集合中

集合框架的分类:

  • List集合/数据结构:线性,数据内容无序,但数据的位置是有序的,位置从零开始的
  • Set集合/数据结构:非线性,数据的内容无序,位置也无序,但内容不能重复
  • Map集合/数据结构:键值对 若干键值对组织在一起的数据

使用上面的三种集合

  1. 集合的初始有一个固定的大小,随着往集合中添加数据,集合的空间不够,那么集合会自动扩容
  2. 可以给集合存储若干不同类型对象数据
  3. 给集合存完元素后,就可以操作集合的数据

List

  • 查找:有位置的下标的数据,查找快,没有位置下标的数据,查找的速度不一定
  • 增加:增加到集合末尾,追加块;增加到集合中的某一个位置,追加慢
  • 删除:有位置下标,删除快,移动数据慢
  • 修改

Set

  • 查找:查找慢
  • 增加:慢,保证集合中的数据没有重复
  • 删除:先找后删
  • 修改

Map

  • 查找:有key数据,查找快;没有key数据,查找速度不一定
  • 增加:慢,因为要保证key不能重复
  • 删除:有key数据,删除快;
  • 修改

集合的继承结构

Collection接口

List接口 List implements Collection ArrayList类 Array implements List
LinkedList类 LinkedList implements List

Set接口 Set implements Collection HashSet类 HashSet implements Set
TreeSet类 TreeSet implements Set

Map接口

HashMap类 HashMap implements Map
Hashtable类 Hashtable implements Map

List集合

List是一个接口,接口定义了规范,要使用这些接口,就必须实现这个接口,并给接口的方法补上方法体
ArrayList类和LinkedList类都是List接口的子实现

List集合常用api

  • boolean add(Object) 给集合添加对象
  • int size() 获取集合中的元素个数
  • Object get(int) 从集合中获取指定下标位置的元素
  • void clear 清除集合中所有的元素
  • boolean isEmpty() 判断集合是否为空,指的是内容为空
  • List subList(int,int)从起始索引到终止索引,包括头,不包括尾(左闭右开)
  • void remove(int) 删除指定索引位置的对象
  • void remove(Object) 删除指定的对象
  • void remove(Collection) 删除集合中的一个子集 ….

集合空:

集合对象为null 集合对象不为null,但集合内容为空

ArrayList类

有具体的下标,通过下标查询速度快,不适合增删

ArrayList可变数组是如何实现动态扩容的,扩容原则:
申请一个更大的新数组
新数组 = Array.copyOf(原数组,新数组长度)
ArrayList集合不适合存储大量数据

空间增长规律
在不添加数据时是0,有第一个数据后就是10 jre1.6及以下是old*3/2+1 默认容量10 16 25 38 jre1.7及以上是old+old»1 1.5倍 默认容量10 15 22

存越多,空间浪费越多

使用方法

增加数据时候的用法

public class ArrayListService {
	/**
	 * 增加:给集合添加数据 1.无论什么对象,被添加到allPerson中,就会变成object类型的对象了
	 * 说明无论什么对象,进入集合后,都变成Object对象,属于自然转换 2.add方法的返回值是boolean,这个返回值没有被使用
	 * 3.非泛型写法,java认为此写法安全,java建议使用泛型
	 * 
	 * @return
	 */
	public ArrayList<Person> addPerson() {
		ArrayList<Person> allPerson = new ArrayList<Person>();
		Student stu1 = new Student("张三", 20, "S001");
		Student stu2 = new Student("李四", 21, "S002");
		Student stu3 = new Student("王五", 22, "S003");
		Student stu4 = new Student("张五", 20, "S004");

		Teacher tea1 = new Teacher("赵六", 30, 10000);
		Teacher tea2 = new Teacher("田七", 35, 20000);

		allPerson.add(stu2);
		allPerson.add(tea1);
		allPerson.add(stu3);
		allPerson.add(tea2);
		allPerson.add(stu1);
		allPerson.add(stu4);
		//allPerson.add(null);

		return allPerson;
	}

遍历集合查找的用法

/**
	 * 遍历集合中的所有元素 注意,从集合中取出数据的时候,都是Object类型
	 * 
	 * @param allPerson
	 */
	public void findPerson1(ArrayList<Person> allPerson) {
		for (int i = 0; i < allPerson.size(); i++) {
			Person p = allPerson.get(i);
			if (p instanceof Student) {
				Student stu = (Student) p;
				System.out.println("name" + stu.getName() + "age" + stu.getAge() + "stuNo" + stu.getStuNo());
			} else if (p instanceof Teacher) {
				Teacher tea = (Teacher) p;
				System.out.println("name" + tea.getName() + "age" + tea.getAge() + "stuNo" + tea.getSalary());
			}
		}
	}
	
	/**
	 * 增强for循环
	 * 
	 * @param allPerson
	 */
	public void findPerson2(ArrayList<Person> allPerson) {
		for (Person p : allPerson) {
			if (p instanceof Student) {
				Student stu = (Student) p;
				System.out.println("name" + stu.getName() + "age" + stu.getAge() + "stuNo" + stu.getStuNo());
			} else if (p instanceof Teacher) {
				Teacher tea = (Teacher) p;
				System.out.println("name" + tea.getName() + "age" + tea.getAge() + "stuNo" + tea.getSalary());
			}
		}
	}

	/**
	 * 此方法输出老师或学生的名字或年龄
	 * 
	 * @param allPerson
	 */
	public void findPerson4(ArrayList<Person> allPerson) {
		for (Person p : allPerson) {
				CommonPerson cp = (CommonPerson) p;
				System.out.println("name" + cp.getName() + "age" + cp.getAge());
		}
	}

	/**
	 * 寻找田七老师,如果找到就输出老师在集合中的位置,如果没找到就输出没找到
	 * 
	 * @param allPerson
	 */
	public void findPerson7(ArrayList<Person> allPerson) {
		int position = 0;
		boolean flag = false;
		for (Person p : allPerson) {
			if (p instanceof Teacher) {
				Teacher tea = (Teacher) p;
				if ("田七".equals(tea.getName())) {
					System.out.println(position);
					flag = true;
					break;
				}
			}
			position++;
		}
		if (position == allPerson.size()) {
			System.out.println("没找到");
		}

修改的用法

/**
	 * 按照名字查找老师,并给薪水翻倍
	 * @param allPerson
	 * @param name
	 */
	public void UpdateSalaryByName(ArrayList<Person> allPerson,String name){
		Person p = this.findPersonByName(allPerson, name);
			if(p!=null && p instanceof Teacher ){
				Teacher tea = (Teacher)p;
				tea.setSalary(tea.getSalary()*2);
						
			}
		}

Set集合

集合中不能有重复的元素出现,所有的Set集合中的元素,只能唯一,没有顺序,能存储null,线程不安全

Set接口:
HashSet集合越小,便利的速度和效率就越好
TreeSet集合是要求集合中的数据排序,要求要存储的元素对象对应的类必须实现Coparable接口

使用方法

添加数据方法

public HashSet<Person> addPerson() {
		HashSet<Person> allPerson = new HashSet<Person>();
		Student stu1 = new Student("张三", 20, "S001");
		Student stu2 = new Student("李四", 21, "S002");
		Student stu3 = new Student("王五", 22, "S003");
		Student stu4 = new Student("张五", 20, "S004");

		Teacher tea1 = new Teacher("赵六", 30, 10000);
		Teacher tea2 = new Teacher("田七", 35, 20000);

		allPerson.add(stu2);
		allPerson.add(tea1);
		allPerson.add(stu3);
		allPerson.add(tea2);
		allPerson.add(stu1);
		allPerson.add(stu4);
		return allPerson;
	}

查找数据的方法

/**
	 * 输出学生的姓名和学号 输出老师的姓名和年龄,薪水
	 */
	public void findPerson1(HashSet<Person> allPerson) {
		for (Person p : allPerson) {
			if (p instanceof Student) {
				Student stu = (Student) p;
				System.out.println("name=" + stu.getName() 
									+ "age=" + stu.getAge() 
									+ "stuNo" + stu.getStuNo());
			} else if (p instanceof Teacher) {
				Teacher tea = (Teacher)p;
				System.out.println("name=" + tea.getName()
				+ "age=" + tea.getAge()
				+ "salary" + tea.getSalary());
			}
		}
	}
	/**
	 * 输出老师和学生的年龄和姓名
	 */
	public void findPerson2(HashSet<Person> allPerson){
		for(Person p: allPerson){
			CommonPerson cp = (CommonPerson)p;
			System.out.println("name=" + cp.getName()
				+ "age=" + cp.getAge());
		}
	}
	/**
	 * 是学生就调用学生的学习方法
	 * 是老师就输出老师的年龄和薪水
	 */
	public void findPerson3(HashSet<Person> allPerson){
		for(Person p:allPerson){
			if (p instanceof Student) {
				Student stu = (Student) p;
				stu.study();
			} else if (p instanceof Teacher) {
				Teacher tea = (Teacher)p;
				System.out.println("name=" + tea.getName()
				+ "age=" + tea.getAge()
				+ "salary" + tea.getSalary());
			}
			
		}
	}
	/**
	 * 寻找田七老师,如果找到了就输出老师的薪水
	 * 如果没有就提示没有
	 */
	public void findPerson4(HashSet<Person> allPerson){
		boolean flag = false;
		for(Person p:allPerson){
			if(p instanceof Teacher){
				Teacher tea = (Teacher)p;
				if("田七".equals(tea.getName())){
					System.out.println("salary"+tea.getSalary());
					flag = true;
					break;
				}
			}
		}
		if(!flag){
			System.out.println("没找到");
		}
	}

删除数据的方法

// 删除
	public void deletePersonByName(HashSet<Person> allPerson,String name){
		Person p = findPersonByName(allPerson,name);
		allPerson.remove(p);
		
	}
	
	private CommonPerson findPersonByName(HashSet<Person> allPerson,String name){
		CommonPerson cp = null;
		for(Person p:allPerson){
			CommonPerson cpp = (CommonPerson)p;
			if(name!=null&& name.equals(cpp.getName()) ){
				cp=cpp;
			}
		}
		return cp;
	}

修改的方法

// 修改
	public void updateSalaryByName(HashSet<Person> allPerson,String name){
		CommonPerson cp = this.findPersonByName(allPerson, name);
		if(cp!=null&&name != null&&cp instanceof Teacher){
			Teacher tea = (Teacher)cp;
			tea.setSalary(tea.getSalary()*2);
		}
	}

Map集合

若干键值对数据组成的集合
map集合中的所有的key(值)也是一个集合,是一个set集合,key不能重复
map集合中的所有的value值也是一个集合,是Collection集合
集合中的每一个元素是由key和value组成的,而value可以是Collection或map集合皆可,即集合套集合

Map接口的两个实现:

HashMap:可以存储null,线程不安全,异步
Hashtable:不可以存储null,线程安全,同步

Map集合的应用场景广泛:

原因:前提是能确定key的值,就一定会快速获取key对应的对象
很多框架中能得到数据就是用map集合存储 Spring框架,Springmvc框架,strutcts框架,mybatis框架,tomcat框架,redis框架等…

map的集合只能通过put方式添加集合元素(键值对)
存储完后,会把所有的key构成一个set集合,此set集合只能读取,不能添加,同理,所有的value组成的集合只能读取不能添加

从map集合中取出集合的数据有三种方式

  1. 一次取出一个键值对
  2. 先取出所有的key,循环遍历key,根据key来取出要value
  3. 直接取出所有的value,进行遍历,找到合适的value即可

使用方法

添加数据的方法

public Map<String,Person> addPerson(){
		Map<String,Person> allPerson = new HashMap<String,Person>();
		Student stu1 = new Student("张三", 20, "S001");
		Student stu2 = new Student("李四", 21, "S002");
		Student stu3 = new Student("王五", 22, "S003");
		Student stu4 = new Student("张五", 20, "S004");

		Teacher tea1 = new Teacher("赵六", 30, 10000);
		Teacher tea2 = new Teacher("田七", 35, 20000);
		allPerson.put(stu1.getName(), stu1);
		allPerson.put(stu2.getName(), stu1);
		allPerson.put(stu3.getName(), stu1);
		allPerson.put(stu4.getName(), stu1);
		allPerson.put(tea1.getName(), tea1);
		allPerson.put(tea2.getName(), tea2);
		
		return allPerson;
	}

查找数据的方法

//遍历集合中的所有的数据(key,value)
	public void findPerson1(Map<String,Person> allPerson){
		//循环遍历,每次只取出一个元素(键值对)
		for(Entry<String,Person> entry:allPerson.entrySet()){
			System.out.println(entry.getKey());
			String key = entry.getKey();
			Person p = entry.getValue();
				if (p instanceof Student) {
					Student stu = (Student) p;
					System.out.println("name=" + stu.getName() 
										+ "age=" + stu.getAge() 
										+ "stuNo" + stu.getStuNo());
				} else if (p instanceof Teacher) {
					Teacher tea = (Teacher)p;
					System.out.println("name=" + tea.getName()
					+ "age=" + tea.getAge()
					+ "salary" + tea.getSalary());
				}
			
		}
	}
	//先从map集合中获取所有的key组成的set组合
	public void findPerson2(Map<String,Person> allPerson){
		//获取map集合中所有的key集合
		Set<String> allkeys = allPerson.keySet();
		for(String key:allkeys){
			//根据指定的key来获取指定的value
			Person p = allPerson.get(key);
				if (p instanceof Student) {
					Student stu = (Student) p;
					System.out.println("name=" + stu.getName() 
										+ "age=" + stu.getAge() 
										+ "stuNo" + stu.getStuNo());
				} else if (p instanceof Teacher) {
					Teacher tea = (Teacher)p;
					System.out.println("name=" + tea.getName()
					+ "age=" + tea.getAge()
					+ "salary" + tea.getSalary());
				}
			
		}
	}
	//直接获取map集合中所有的value组成的集合
	public void findPerson3(Map<String,Person> allPerson){
		//获取map集合中所有的value集合
		Collection<Person> ps = allPerson.values();
		
		for(Person p:ps){
				if (p instanceof Student) {
					Student stu = (Student) p;
					System.out.println("name=" + stu.getName() 
										+ "age=" + stu.getAge() 
										+ "stuNo" + stu.getStuNo());
				} else if (p instanceof Teacher) {
					Teacher tea = (Teacher)p;
					System.out.println("name=" + tea.getName()
					+ "age=" + tea.getAge()
					+ "salary" + tea.getSalary());
				}
		}
	}

删除的方法

public void deletePerson1(Map<String, Person> allPerson){
		allPerson.clear();
		if(allPerson.isEmpty()){
			System.out.println("全部清除!");
		}
		
	}
	public void deletePerson2(Map<String, Person> allPerson,String key){
		allPerson.remove(key);
		
		
	}
	public void deletePerson3(Map<String,Person> allPerson,int age){
		String[] keys = new String[allPerson.size()];
		int count = 0;
		for(String key:allPerson.keySet()){
			Person p = allPerson.get(key);
			CommonPerson cp = (CommonPerson)p;
			if(cp.getAge()==age){
				keys[count++]=key;
			}
		}
		for(int i=0;i<count;i++){
			allPerson.remove(keys[i]);
		}
	}

修改的方法

public void updateSalaryByName(Map<String,Person> allPerson,String name){
		Person p = allPerson.get(name);
		if(p!=null&&p instanceof Teacher){
			Teacher tea = (Teacher)p;
			tea.setSalary(tea.getSalary()*2);
		}
	}

集合套集合

解决了更复杂的数据结构问题

 ArrayList<List> all = new ArrayList<List>();
 ArrayList<Collection> all = new ArrayList<Collection>();
 ArrayList<Map<String,List<Collection>>> all = new ArrayList<Map<String,List<Collection>>>();
 Map<String,Collection> all = new HashMap<String,Collection>();
 Map<String,Map<String,Collection>> all = new HashMap<String,Map<String,Collection>>();

上一篇 静态代码块,静态属性和有继承时的执行顺序

下一篇 装箱和String

Comments

Content