学习笔记——day17 18 19(集合完整版)

最新推荐文章于 2020-07-01 17:18:21 发布

陈肉肉

最新推荐文章于 2020-07-01 17:18:21 发布

阅读量304

点赞数

分类专栏：学习笔记

本文链接：https://blog.csdn.net/Katherine_c/article/details/97808309

版权

学习笔记专栏收录该内容

31 篇文章 0 订阅

订阅专栏

集合

集合：数据集合 (用来存储数据的集合)

1：为什么需要学习java中的集合框架：
学习数组可以用来存储数据：
数组的存储数据的弊端:
a:存储相同数据类型的有序集合
存储的数据是相同类型的
b:数组存储数据时需要指定当前数组的长度而且长度不可变 (定长)
需求：使用数组存储学生信息效率变低
使用数组存储每天的新闻信息

就是由于在大多数的应用场景中，数据都是动态的，导致数组存储要么浪费空间，要么浪费效率
2：java提供了一套功能强大的集合框架，来帮助存储数据信息。
3:为什么java提供了这么多集合对象存储数据信息?

这么多集合对象用来在不同的需求场景使用。
本质上而言其实不同的集合对象底层存储实现方案不同不同的存储结构适用不同的需求

1 3 6 9

一张图

在这里插入图片描述

3个知识点

泛型：

泛型：jdk1.5之后的新特性
数据类型

1：什么是泛型?

广泛的类型也是一种数据类型而这种数据类型可以是任意类型编写过程当中不能确定该类型
创建对象时可以指定泛型的具体类型

2：泛型是编译期行为

泛型是编译期行为，只能在编译器有效如果能够跨过编译期那么泛型就没有任何意义
泛型类

3：如何定义泛型类

	 	 在类后加<> 括号中编写任意长度任意字符  不能是数值
	 	一般情况下我们通过大写的26个字母去声明当前泛型  T type E element
	  	
	  	使用：
	  		jdk1.7之后支持泛型的类型推断
	  		泛型类<具体类型> 变量名 = new 泛型类<>();

4：泛型接口

	  	实现类实现泛型接口时不指定泛型类型  此时创建实现类对象是可以指定泛型类型
	  	class UserServiceImpl<T> implements UserService<T>
	  	实现类实现泛型接口时指定泛型类型 那么将确定泛型类型
	  	class UserServiceImpl implements UserService<String>

5：泛型方法

	  	方法中使用泛型 该方法就是一个泛型方法
		静态方法无法使用泛型类中声明的泛型类型 因为泛型类型的确定是创建对象时确定的
		而静态方法是先于对象存在的 ，如果要使用，在当前静态方法上声明泛型类型
		public static <泛型类型>  vaid 方法名()

//泛型类
public class Genric<E> {

	//泛型方法
	public void add(E e) {
		
	}
	
	//static修饰的泛型方法
	public static <T> void fun(T ... e) {
		
	}
}


public class Test {
	public static void main(String[] args) {
		
		//使用泛型类
		Genric<Integer> g = new Genric<Integer>();//对于当前g对象而言 它的泛型E的类型是String
		g.add(123);
		
		//声明泛型类 不指定泛型的具体类型
		Genric g1 = new Genric();
		g1.add("123");// 此时泛型E的类型是String
		g1.add(1);//此时泛型类型是Integer
		
		
		Genric.fun("123");
		
	}
}

//泛型接口 
interface UserService<T>{
	public void fun(T t);
}
//泛型接口  不指定类型
class UserServiceImpl<T> implements UserService<T>{

	@Override
	public void fun(T t) {
		// TODO Auto-generated method stub
		
	}
}

迭代器：

	Iterable 是java.lang包下的接口  实现该接口都能够作为foreach的目标
	Iterator 是java.util包下的接口  迭代器 用来迭代当前集合对象的
	Iterator 是一个接口  ArrayList中通过内部类完成了对于改接口的实现 获取的其实是实现类对象

比较器：

外部比较器：

		java.util.Compartor接口指定的。
		如果要使用外部比较器，实现该接口 重写compare方法
		自定义排序规则  可以随着业务扩展随时变化的

内部比较器

		java.lang.Comparable接口指定
		如果要使用内部比较器，实现该接口 重写compareTo方法
		不利于后期扩展

6个接口

Collection:

定义：
			public interface Collection<E> extends Iterable<E>
			<E> -->     Object
			Iterable: 接口   凡是继承/实现了Iterable的类 都能够作为foreach的目标
			
			Iterable 是java.lang包下的接口  实现改接口都能够作为foreach的目标
			Iterator 是java.util包下的接口  迭代器 用来迭代当前集合对象的
		
		常见方法：
			add 、clear、remove、addAll、removeAll、retainAll、size、isEmpty、contains、
			containsAll、iterator
		迭代方法：
			foreach、迭代器

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

/* 
 *   Collection:
 *   	存储元素的特点  无序  可重复  对于所有的集合框架中的对象 只能存储引用类型  
 * 	
 * 		添加元素
 * 				add(Object) 添加元素 返回是否添加成功 true/false			
 * 				addAll(Coll) 添加一个集合
 * 		删除元素
 * 				clear()清空所有元素
 * 				remove()移除一个
 * 				removeAll(Coll)  移除交集 
 * 				retainAll(Coll)  保留交集
 * 		修改元素
 * 				没有修改元素
 * 		查看元素
 * 				isEmpty
 * 				size
 * 				contains 
 * 				containsAll
 * 		迭代元素
 * 				
 * 
 * 
 * 
 * 
 *   @SuppressWarnings : 注解  用来抑制警告
 *   
 */
@SuppressWarnings("all")
public class Test01 {
	public static void main(String[] args) {
		
		
	
		// 学习接口中的方法  接口指向实现类对象
		Collection coll = new ArrayList();
		
		
		//添加元素
		coll.add("java");// Object obj = "java" 自动类型转换
		coll.add(1);// Integer in1 = Integer.valueOf(1);  Object obj = in1;
		
		
		//添加元素
		Collection coll1 = new ArrayList();
		coll1.add("html");
		coll1.add("spring");
		
		System.out.println("往coll中添加coll1："+coll.addAll(coll1));
		
		
		
		
		//删除元素：
		//coll.clear();
		System.out.println("移除不存在的元素："+coll.remove("spring"));
		//System.out.println(coll.removeAll(coll1));
		
		
		System.out.println("coll中的元素："+coll);
		System.out.println(coll.retainAll(coll1));
		System.out.println("coll中的元素："+coll);
		
		
		
		
		//查看元素
		System.out.println("查看当前集合是否为null:"+coll.isEmpty());
		System.out.println("查看当前集合元素个数："+coll.size());
		System.out.println("查看当前集合是否包含元素1："+coll.contains("1"));
		
	}
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//   目前情况下不要再迭代元素过程中强转类型  可能会引发问题  classcaseexception
public class Test02 {
	public static void main(String[] args) {
		
		//创建集合对象
		Collection coll = new ArrayList();
		
		//添加元素
		coll.add("String");
		coll.add("1");
		coll.add("Integer");
		coll.add("Scanner");
		
		
		//迭代元素
		System.out.println("foreach循环迭代");
		for(Object obj:coll) {
			String str = (String)obj;
			System.out.println(str);
		}
		
		
		System.out.println("iterator 迭代器");
		Iterator it = coll.iterator();//实现类对象
		while(it.hasNext()) {//下面是否存在元素  如果存在元素 返回true 如果不存在返回false
			//获取元素
			System.out.println(it.next());
		}
		
		System.out.println("迭代器的变种写法");
		for(Iterator it1 = coll.iterator();it1.hasNext();) {
			System.out.println(it1.next());
		}
	}
}

List:

有序可重复可以是null值
定义：public interface List extends Collection
常见方法：
增加：
add(index,obj) add(obj) addAll(Coll) addAll(index,coll)
删除：
remove(index/obj) clear() removeAll(Coll) retainAll(coll)
修改：
set(index,obj)
查看：
indexOf(obj) lastIndexOf(obj) subList(sindex,eindex)
isEmpty() get(index) size() contains(obj) contaisAll(coll)
迭代：
普通for 增强for 迭代器(iterator[不能支持并发修改] listIterator[支持并发修改])

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

/*
 *   使用List接口
 * 	 多了一些针对于索引的操作，获取元素时 索引从0开始
 * 
 */
public class Test03 {
	public static void main(String[] args) {
		
		//创建对象
		List ls = new ArrayList();
		
		//添加元素
		ls.add(1);
		ls.add(1, "魏无羡");//无返回值
		ls.add(2);  //[1，魏无羡，2]
		ls.add("蓝忘机");
		
		
		//删除操作
		ls.remove(Integer.valueOf(1));// int   Object
		
		
		//修改
		ls.set(0, "蓝湛");
		
		
		
		
		//查看元素
		System.out.println("为null判定："+ls.isEmpty());
		Object obj = ls.get(0);
		System.out.println("查看指定位置上的元素："+obj);
		System.out.println(ls);
		
		
		List newLs = ls.subList(0, 1);//截取指定位置上的元素
		System.out.println(newLs);
		
		
		System.out.println("查询指定元素的所有："+ls.indexOf(2));
		System.out.println("查询指定元素的索引(最后一次)："+ls.lastIndexOf("嘿嘿"));
		System.out.println("元素个数："+ls.size());
		
	}
}

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

public class Test04 {
	public static void main(String[] args) {
		
		//创建对象
		List ls = new ArrayList();
		
		ls.add("姑苏蓝氏  蓝忘机");
		ls.add("云梦江氏  魏无羡");
		ls.add("兰陵金氏 金子轩");
		ls.add("岐山温氏  温宁");
		
		//迭代
		System.out.println("普通for循环");
		for(int i = 0;i<ls.size();i++) {
			System.out.println(ls.get(i));
		}
		
		System.out.println("foreach循环");
		for(Object obj:ls) {
			System.out.println(obj);
		}
		
		System.out.println("迭代器循环");
		for(Iterator it = ls.iterator();it.hasNext();) {//hasNext()判定它下一个是否有值
			System.out.println(it.next());//如果有 输出下一个的值
		}
		
	}
}

ListIterator

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

/* 
 * 
 *    java.util.ConcurrentModificationException 
 *  查看当前是否存在"兰陵金氏 金子轩" 如果存在则添加元素 "清河聂氏  聂怀桑"   只能通过for循环完成，
 *增强for以及iterator都会报异常   java.util.ConcurrentModificationException   并发修改异常
 *   增强for循环 底层使用迭代器，而对于迭代器而言，它也指向了集合对象，ls指向集合对象要执行添加操作，迭代器对象
 *   指向集合要执行迭代操作，此时会出现并发修改问题，那么程序报错
 */
public class Test05 {
	public static void main(String[] args) {
		//创建对象
		List ls = new ArrayList();
		
		ls.add("姑苏蓝氏  蓝忘机");
		ls.add("云梦江氏  魏无羡");
		ls.add("兰陵金氏 金子轩");
		ls.add("岐山温氏  温宁");
		
		// 查看当前是否存在"兰陵金氏 金子轩" 如果存在则添加元素 "清河聂氏  聂怀桑"
		/*
		 * System.out.println("普通for循环"); 
		 * for(int i = 0;i<ls.size();i++) {
		 * if("兰陵金氏 金子轩".equals(ls.get(i))) {
		 *  ls.add("清河聂氏  聂怀桑"); 
		 *  }
		 *   }
		 */
		System.out.println(ls);
	
		/*
		 * System.out.println("foreach循环");
		 *  for(Object obj:ls) {
		 *   //强转 String str = (String)obj; 
		 *   if("兰陵金氏 金子轩".equals(str)) { 
		 *   ls.add("清河聂氏  聂怀桑"); 
		 *   }
		 * 
		 * }
		 * 
		 * System.out.println(ls);
		 */
		
		
		/*
		 * System.out.println("迭代器循环");
		 *  Iterator it = ls.iterator();
		 *   while(it.hasNext()){ 
		 *  if("兰陵金氏 金子轩".equals(it.next())) {
		 *   ls.add("清河聂氏  聂怀桑"); 
		 *   } 
		 *   }
		 * System.out.println(ls);
		 */
		
		
		//System.out.println("=========ListIterator=========");
		ListIterator iterator = ls.listIterator();
		
		while(iterator.hasNext()) {
			if("兰陵金氏 金子轩".equals(iterator.next())) {
				iterator.add("清河聂氏  聂怀桑");
			}
		}
		System.out.println(ls);
	}
}

正序/逆序迭代

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

public class Test06 {
	public static void main(String[] args) {
		
		//创建对象
		List ls = new ArrayList();
		
		//添加元素
		ls.add("姑苏蓝氏  蓝忘机");
		ls.add("云梦江氏  魏无羡");
		ls.add("兰陵金氏 金子轩");
		ls.add("岐山温氏  温宁");
		
		System.out.println("正序迭代");
		ListIterator it = ls.listIterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		
		
		System.out.println("逆序迭代");
	   
		
	    while(it.hasPrevious()) {
	    	System.out.println(it.previous());
	    }
	}
}

set

无序唯一
定义：public interface Set extends Collection
常见方法：
add(不能添加已经存在的元素) 、clear、remove、addAll、removeAll、retainAll、size、isEmpty、contains、
containsAll、iterator
迭代方法：
foreach、迭代器

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

public class Test01 {
	public static void main(String[] args) {
		
		// Set
		Set<String> sets = new HashSet<>();
		
		
		//添加
		sets.add("格莱美");
		sets.add("奥斯卡");
		sets.add("图灵奖");
		
		System.out.println(sets.add("图灵奖"));
		System.out.println(sets);//不能添加已经存在的元素
		
		
		System.out.println("迭代元素");
		for(String str:sets) {
			System.out.println(str);
		}
		
		System.out.println("迭代元素 迭代器");
		Iterator<String> it = sets.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		
		
	}
}

Map：

		数据： k-v  键值的方式存储
		k：唯一 无序  (set)     v  无序可重复 (collection)
		常见方法：
			put(k,v)  get(k)  containsKey(k)		keySet()
			remove(k)  size()  containsValue(v)		values()
		迭代方法：
			获取键 迭代键的过程中通过get方法获取值
				for(Object key:keySet()){
					sout(k+"="+map.get(k));
				}
			获取Entry对象，通过getKey和getValue获取键和值
			//获取entry对象
			Set<Entry<String, String>> kvs = mps.entrySet();// 返回一个set集合 该集合中的每个元素都是entry对象
			// 实际是 HashSet中的Node对象 因为Node实现了Map中的Entry接口
			for(Entry<String, String> entry:kvs) {
				System.out.println(entry.getKey()+"==="+entry.getValue());
			}

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

public class Test01 {
	public static void main(String[] args) {
		
		// 创建map对象
		Map<String,String> mps = new HashMap<>();
		
		
		//put  如果存在键 返回对应的值  添加的值会覆盖之前的值
		mps.put("圣枪游侠", "奥巴马");
		mps.put("皮城女警", "女警");
		mps.put("德玛西亚", "大宝剑");
		
		System.out.println(mps.put("圣枪游侠", "卢锡安"));
		
		
		System.out.println(mps.remove("德玛西亚"));//如果键不存在 返回null 如果存在返回值
		
		
		System.out.println(mps);
		System.out.println(mps.size());
		System.out.println("获取键对应的值："+mps.get("皮城女警"));//如果键不存在 返回null 如果存在返回值
		
		System.out.println("查看键是否存在："+mps.containsKey("皮城女警"));
		System.out.println("查看值是否存在："+mps.containsValue("女警"));
		
	}
}

迭代

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

public class Test02 {
	public static void main(String[] args) {
		
		// 创建map对象
		Map<String,String> mps = new HashMap<>();
		
		
		//put  如果存在键 返回对应的值  添加的值会覆盖之前的值
		mps.put("圣枪游侠", "奥巴马");
		mps.put("皮城女警", "女警");
		mps.put("德玛西亚", "大宝剑");
		
		
		//迭代元素
		System.out.println("迭代所有的key");
		Set<String> keys = mps.keySet();
		for(String key:keys) {
			System.out.println(key+"==="+mps.get(key));
		}
		
		
		System.out.println("迭代所有的值value");
		Collection<String> coll = mps.values();
		for(String value:coll) {
			System.out.println(value);
		}
		
		//获取entry对象
		Set<Entry<String, String>> kvs = mps.entrySet();// 返回一个set集合 该集合中的每个元素都是entry对象
		// 实际是 HashSet中的Node对象 因为Node实现了Map中的Entry接口
		for(Entry<String, String> entry:kvs) {
			System.out.println(entry.getKey()+"==="+entry.getValue());
		}
		
	}
}

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

public class Test03 {
	public static void main(String[] args) {
		TreeMap<String,Integer> ts = new TreeMap<>();
		
		ts.put("balabala小魔仙",30 );
		ts.put("z jake",136 );
		ts.put("yakamaka 花园宝宝", 45);
		
		
		System.out.println(ts);
		
		System.out.println("查找大于或等于给定元素的最小元素："+ts.ceilingKey("p"));
		System.out.println("查找大于或等于给定元素的最小元素："+ts.ceilingEntry("p"));
		
		/*
		 * System.out.println("查找大于或等于给定元素的最小元素："+treeSet.ceiling("e"));
		 * System.out.println("查找大于给定元素的最小元素："+treeSet.higher("e"));
		 * System.out.println("获取最小元素："+treeSet.first());
		 * System.out.println("获取最大元素："+treeSet.last());
		 * 
		 * System.out.println("查找小于或等于给定元素的最大元素："+treeSet.floor("e"));
		 * System.out.println("查找小于给定元素的最大元素："+treeSet.lower("e"));
		 */
		
		Set<String> sets = ts.keySet();
		for(String key:sets) {
			System.out.println(key+"="+ts.get(key));
		}
		
		
		Set<Entry<String, Integer>> kvs = ts.entrySet();
		for(Entry<String, Integer> entry:kvs) {
			System.out.println(entry.getKey()+"="+entry.getValue());
		}
		
		
	}
}

9个常用类

ArrayList

ArrayList: 扩容2倍
底层：数组
优缺点分析：通过索引获取元素以及迭代元素比较快但是添加、删除很慢
常见方法：和List一致
迭代方式：和List一致

import java.util.ArrayList;

public class Test07 {
	public static void main(String[] args) {
		
		//1:创建对象
		ArrayList<String> ls = new ArrayList<>();
		
		//添加元素
		ls.add("人在囧途");
		ls.add("扫毒");
		ls.add("七龙珠");
		ls.add(1,"头号玩家");
		
		
		ls.remove(1);
		
		
		System.out.println(ls.contains("天线宝宝"));
		
		System.out.println(ls);
		System.out.println(ls.subList(0, 2));
	}
}

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

public class Test08 {
	public static void main(String[] args) {
		ArrayList<String> ls = new ArrayList<>();
		
		//添加元素
		ls.add("人在囧途");
		ls.add("扫毒");
		ls.add("七龙珠");
		ls.add(1,"头号玩家");
		
		for(int i = 0;i<ls.size();i++) {
			System.out.println(ls.get(i));
		}
		
		for(String str:ls) {
			System.out.println(str);
		}
		
		for(Iterator<String> it = ls.iterator();it.hasNext();) {
			System.out.println(it.next());
		}
		
		
	}
}

LinkedList

底层：双向链表
优缺点: 添加、删除快获取元素慢
常见方法：和List一样多了一些头尾操作：

查看 getFirst getLast element头 peek peekFirst peekLast
删除 poll pollFirst pollLast removeFirst removeLast
添加 offer offerFirst offerLast addFirst addLast

import java.util.LinkedList;

/*
 * 	 尝试编写LinkedList 
 * 
 *     LinkedList: 多了一些头尾的操作
 * 
 * 
 */
public class Test09 {
	public static void main(String[] args) {
		
		//1: 创建对象
		LinkedList<String> ls = new LinkedList<>();
		
		//2:添加元素
		ls.add("不知火舞");
		
		
		System.out.println(ls.get(0));	
		System.out.println(ls);
		
		ls.add("橘右京");
		ls.add("娜可露露");
		ls.add("宫本武藏");
		
		
		// 多了一些针对于头尾元素的操作
		ls.addFirst("草薙京");
		ls.addLast("八神庵");
		System.out.println(ls.offer("春丽"));//添加到末尾
		System.out.println(ls.offerFirst("春丽"));//添加到末尾
		System.out.println(ls.offerLast("春丽"));//添加到末尾
		
		System.out.println(ls);
		
		System.out.println(ls.element());//获取头元素
		System.out.println(ls.getFirst());
		System.out.println(ls.getLast());
		
		System.out.println(ls);
		
		//ls = null;
		System.out.println(ls.peekFirst());
		
		System.out.println(ls.peek());
		
	}
}

Vector:

	底层：数组  线程安全   速度慢  安全   1.5倍

HashSet

在这里插入图片描述

底层：数组+链表?
优缺点：添加、删除、修改效率都很高
常见方法：
add 、clear、remove、addAll、removeAll、retainAll、size、isEmpty、contains、
containsAll、iterator
迭代方法：
foreach、迭代器
注意事项：
hashset存储自定义对象时一定要重写hashcode和equals方法。

import java.util.HashSet;

/*
 * 
 *    Hashset存储自定义对象
 * 
 */
public class Test02 {
	public static void main(String[] args) {
		
		//创建一个HashSet
		HashSet<User> ss = new HashSet<>();
		
		//添加User对象
		ss.add(new User(6300,"疾风剑豪"));
		ss.add(new User(4800,"雷霆咆哮"));
		
		ss.add(new User(6300,"疾风剑豪"));
		
		System.out.println(ss);
	}
}
class User{
	
	private int money;
	private String name;
	
	public User() {
		// TODO Auto-generated constructor stub
	}

	public User(int money, String name) {
		super();
		this.money = money;
		this.name = name;
	}

	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "User [money=" + money + ", name=" + name + "]";
	}

	
	// ctrl+shift+s h  hashCode重写快捷键
	
	
	

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + money;
		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;
		User other = (User) obj;
		if (money != other.money)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

import java.util.HashSet;

public class Test03 {
	public static void main(String[] args) {
		
		//创建一个HashSet
		HashSet<Hero> ss = new HashSet<>();
		
		//添加User对象
		//只有一个对象 因为hashCode的返回值是1  equals返回true
		ss.add(new Hero("蜘蛛侠","宝宝吐丝"));
		ss.add(new Hero("钢铁侠","有钱就是任性"));
		
		ss.add(new Hero("雷神","8080"));
		
		System.out.println(ss);
		
	}
}
class Hero{
	
	private String name;
	private String type;
	
	public Hero(String name, String type) {
		super();
		this.name = name;
		this.type = type;
	}

	public String getName() {
		return name;
	}

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

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}
	
	@Override
	public int hashCode() {
		return 1;
	}
	
	@Override
	public boolean equals(Object obj) {
		return true;
	}
	
}

TreeSet

在这里插入图片描述

底层：树红黑树 / 二叉树 / 平衡树
优缺点：维护数据的大小（有序），添加速度和删除速度高于ArrayList 比其他的都低
查询速度高于List 低于Hash。
如果对于存储的数据有排序的要求，那么首选TreeSet。
常见方法：
add 、clear、remove、addAll、removeAll、retainAll、size、isEmpty、contains、
containsAll、iterator
多了一些针对于排序元素的操作 first last floor ceiling higher lower
迭代方法：
foreach、迭代器
注意事项：
如果存储的元素需要按照指定的需求进行排序，创建TreeSet对象时指定比较器。
如果存在的元素是自定义对象：
1：要么自定义对象的所属类实现了内部比较器Comparable接口重写compareTo方法
2：要么创建TreeSet对象是指定外部比较器Comparetor接口重写compare方法

set中每个元素存储的时候都是存储在一个map集合中 map集合的键是set中的元素， map中的值是自动添加的一个默认值

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

public class Test04 {
	public static void main(String[] args) {
			
		TreeSet<String> treeSet = new TreeSet<>();
		
		//添加元素
		treeSet.add("o");
		treeSet.add("a");
		treeSet.add("b");
		treeSet.add("e");
		treeSet.add("j");
		
		System.out.println(treeSet);
		//查找
		System.out.println("查找大于或等于给定元素的最小元素："+treeSet.ceiling("e"));
		System.out.println("查找小于或等于给定元素的最大元素："+treeSet.floor("e"));
				
		System.out.println("查找大于给定元素的最小元素："+treeSet.higher("e"));
		System.out.println("查找小于给定元素的最大元素："+treeSet.lower("e"));
				
		System.out.println("获取最小元素："+treeSet.first());
		System.out.println("获取最大元素："+treeSet.last());
				
		//foreach循环
		for(String str:treeSet) {
			System.out.println(str);
		}
				
		//迭代器循环
		Iterator it = treeSet.descendingIterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

按长度输出

import java.util.Comparator;
import java.util.TreeSet;

/*
 * 
 *   通过treeset存储字符串 然后保证  输出顺序按照  字符串的长度   长度的长的 在后面
 *   
 */
public class Test05 {
	
	public static void main(String[] args) {
		MyCom m = new MyCom();
		//  传入一个比较器
		//TreeSet<String> treeSet = new TreeSet<>(new MyCom());
		
		
		
		TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.length()-o2.length();
			}
		});
		
		
		//TreeSet<String> treeSet = new TreeSet<>((o1,o2)-> -1);
		
		
		//添加元素
		treeSet.add("oracle");
		treeSet.add("ajax");
		treeSet.add("bootstrap");
		treeSet.add("ejb");
		treeSet.add("java");
		
		/*
		 *      o
		 *     / 
		 *    a
		 * 	   \
		 *      b
		 *       \
		 *    	  e
		 *         \
		 *          j 
		 */  
		System.out.println(treeSet);
		
		
		
		
	}
	
	
}

class MyCom implements Comparator<String>{

	@Override
	public int compare(String o1, String o2) {
		return o1.length()-o2.length();
	}
}

HashMap：

计算key值
底层：数组+链表?
优缺点：添加、删除、修改效率都很高
存储自定义对象作为键时要保证当前自定义类重写hashcode和equals方法
什么情况下要重写，当前两个对象的属性相同我们觉得是同一个对象此时要重写。

在这里插入代码片

Arrays

	针对数组

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

/*
 *   
 * Arrays.asList 返回的是Arrays类中的内部类ArrayList 
 * 而这个类的对象是不允许添加以及删除元素的，也就是返回的集合对象是一个长度不可变的ArrayList。
 *  
 *  toArray ->  集合转数组
 *  asList  ->  数组转集合
 *  
 */
public class Test02 {
	public static void main(String[] args) {
		
		String[] strs = new String[] {"J","Q","K","A"};
		List<String> ls = Arrays.asList(strs);
		
		System.out.println(ls);
		
		//ls.remove("A");
		//ls.remove(1);
		System.out.println(ls);
		
		//查找   sort   fill copy   copyRange    toString
		Arrays.sort(strs);
		System.out.println(Arrays.toString(strs));
		
		
		System.out.println(Arrays.binarySearch(strs, "J"));
		
		
		Arrays.fill(strs, "小猫");
		System.out.println(Arrays.toString(strs));
		
		
		strs = Arrays.copyOf(strs, strs.length);
		System.out.println(Arrays.toString(strs));
		
		
		strs = Arrays.copyOfRange(strs, 0, 2);
		System.out.println(Arrays.toString(strs));
		
		
		
		List<String> lls = new ArrayList<>();
		Object[] objs = lls.toArray();
		System.out.println(Arrays.toString(objs));
		
		
		
		
		
	}
}

Collections

	针对集合操作

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

/*
 *   jdk1.9:
 *   	只能没有构造器  非静态方法一定是私有的 
 *   	default方法
 *   
 *   class   interface   方法   变量 
 *  
 *  
 *   Collections通过了一组方法  synchronizedXXX(XXX) 
 *   	该组方法可以针对传入的集合对象 做线程同步，返回能够同步的线程安全的集合对象
 *   	不一定是线程安全的。 及其特殊的情况下会发生问题。
 *   
 *   	解决办法：
 *   		concurrent包下的同步集合实现 同步集合在jdk1.8之后采用分段锁机制完成对于数据的加锁操作 提高效率
 *   
 *   
 *   public static Single getInstance(){
 *   	if(single==null){
 *   		single = new Single();
 *  	}
 *   	return sigle;
 *   }
 *   
 */
public class Test01 {
	public static void main(String[] args) {
		
		//使用Collections
		List<String> ls = new ArrayList<>();
		
		Collections.sort(ls);
		
		//添加元素到集合中去
		Collections.addAll(ls,"heihei","hehe","xixi" );
		
		
		//使用binarySearch查找元素  一定要先排序  返回的是排序之后的元素索引位置
		System.out.println(Collections.binarySearch(ls, "heihei"));
		
		System.out.println(ls);
		//对于集合中的元素进行排序
		Collections.sort(ls);//[hehe, heihei, xixi]
		
		
		System.out.println(Collections.binarySearch(ls, "heihei"));
		
		System.out.println(ls);
		
		//Collections.fill(ls, "dundun");
		
		Collections.shuffle(ls);
		
		System.out.println(ls);
		
		Collections.reverse(ls);
		System.out.println(ls);
	}
}

陈肉肉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习笔记——day17 18 19(集合完整版)

集合集合：数据集合 (用来存储数据的集合)1：为什么需要学习java中的集合框架：学习数组可以用来存储数据：数组的存储数据的弊端:a:存储相同数据类型的有序集合存储的数据是相同类型的b:数组存储数据时需要指定当前数组的长度而且长度不可变 (定长)需求：使用数组存储学生信息效率变低使用数组存储每天的新闻信息就是由于在大多数的应用场景中，数据都是动态的，导致数组存储要么浪费...
复制链接

扫一扫