Java集合知识点详细概括加代码解释

最新推荐文章于 2024-03-14 03:30:07 发布

哈喽沃耳德

最新推荐文章于 2024-03-14 03:30:07 发布

阅读量414

点赞数

分类专栏： Java笔记文章标签： Java 集合Collection ArrayList LinkedList Map

本文链接：https://blog.csdn.net/qq_38118222/article/details/89298699

版权

Java笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

集合Collection （List And Set）

1.在实际开发中，需要将使用的对象存储于特定的数据结构容器中。JDK提供了这样的容器-集合(Collection)。

2.Collection 是一个接口，其子接口有：List和Set

3.List和Set的区别：List是有序可重复集（可以存储重复元素），Set是无序不可重复集（不能存储重复元素）。元素是否重复取决于元素的equals（）比较结果。

集合持有对象的引用

集合中存储的都是引用类型元素，并且集合只保存每个元素的引用，而非将元素本身存入集合。基本类型数据会自动装箱为Integer类型数据。

Collection 中的常用方法

add()方法

1.Collection 定义了一个add方法用于向集合中添加新元素

		-boolean add(E e) E表示的是数据类型
该方法会将给定的元素加进集合 若添加成功则返回true，否则返回false

演示代码如下：

public void testAdd() {
 	Collection<String> c = new ArrayList<String>();
 	System.out.println(c);//[]
 	c.add("a");
 	c.add("b");
 	c.add("c");
 	System.out.println(c);//[a,b,c]
 }

contains()方法

	-boolean contains(Object o)
该方法用于判断给定的元素是否包含在集合中，若包含则返回true，否则返回false。
注意：集合判断元素是否被包含在集合中是根据equals方法，进行比较后的结果。
通常类有必要重写equals方法 来保证比较的合理性。

演示代码如下：

	public void  testContains() {
		Collection<Person> persons = new ArrayList<Person>();
		persons.add(new Person("张三",20));
		persons.add(new Person("李四",21));
		persons.add(new Person("王五",22));
		persons.add(new Person("赵六",23));
		Person p =new Person("李四",21);
		//List集合contains方法和对象的equals方法有关
		boolean flag = persons.contains(p);
		//如果Person类不重写equals方法将为false
		System.out.println(flag);//true
	}

int size()，void clear，boolean isEmpty

-int size()返回当前集合中元素的总数
-void clear() 该方法清空当前集合
-boolean isEmpty()该方法用于判断集合是否为空

演示代码如下：

	public void testSizeAndClearAndIsEmpty() {
		Collection<String> c = new HashSet<String>();
		System.out.println(c.isEmpty());//true
		c.add("Java");
		c.add("C");
		c.add("php");
		c.add("C#");
		c.add("Java");
		System.out.println(c);//无序不可重复：[C#, Java, C, php]
		System.out.println("isEmpty:"+c.isEmpty()+",size:"+c.size());//false  4
		c.clear();
		System.out.println("isEmpty:"+c.isEmpty()+",size:"+c.size());//true 0
	}

addAll()方法和containsAll()方法

	-boolean addAll(Collection<? extends E> c)
该方法需要我们传入一个集合，并将该集合中的所有元素添加到当前集合中
如果此collection 由于调用而发生更改，则返回true
	-boolean containsAll(Collection<?> c)
该方法用于判断当前集合是否包含给定集合中的所有元素
若包含则返回true

演示代码如下：

   public void testAddAllAndContainsAll() {
   	Collection <String >c1 = new ArrayList<String>();
   	c1.add("java");
   	c1.add("c");
   	c1.add("php");
   	c1.add("c#");
   	c1.add("js");
   	System.out.println(c1);//java c php c# js
   	Collection <String> c2 = new HashSet<String>();
   	c2.addAll(c1);
   	System.out.println(c2);//无序 java php c js c#
   	Collection <String>c3= new ArrayList<String>();
   	c3.add("java");
   	c3.add("c");
   	System.out.println(c1.containsAll(c3));//true
   }
   }

迭代器 Iterator

迭代器用于遍历集合元素，获取迭代器可以使用Collection定义的方法：

Iterator <E> it = 集合名.iterator();

迭代器是一个接口，集合在重写了Collection的iterator()方法时利用内部类提供了迭代器的实现。

Iterator提供了统一的遍历集合的方式，其提供了用于遍历集合的两种方法：

boolean hasNext()：判断集合是否还有元素可以遍历
E next():返回迭代的下一个元素

演示代码如下：

	public void testHashNextAndNext() {
		Collection<String> c = new HashSet<String> ();
		c.add("java");
		c.add("c");
		c.add("c#");
		c.add("php");
		c.add("python");
		//获取迭代器
		Iterator<String> it = c.iterator();
		//判断是否有元素 然后遍历
		while(it.hasNext()) {
			//返回元素
			String s = it.next();
			System.out.println(s);
		}
	}

remove()方法

在使用迭代器遍历集合时，不能通过集合的remove()删除集合中的元素，否则会抛出并发更改异常。

void remove()
1.我们通常使用迭代器自身提供的remove()方法来删除通过next()方法迭代出来的元素。
2.迭代器的删除方法是在原集合中删除元素。
3.这里需要注意的是：在调用remove方法前必须通过迭代器的next方法迭代过的元素，
那么删除的就是这个元素，并且不能再次调用remove方法，除非再次调用next方法后
方可调用remove()方法

演示代码如下：

	public void testRemove() {
		Collection<String> c = new HashSet<String>();
		c.add("java");
		c.add("C");
		c.add("C#");
		c.add("PHP");
		c.add("python");
		System.out.println(c);
		Iterator<String> it = c.iterator();
		while(it.hasNext()) {
			String s = it.next();
			if(s.indexOf("C")!= -1) {  //不等于-1 是找到 等于-1没有找到
				it.remove();//删除包含字母C的元素
			}
		}
		System.out.println(c);//python java php 把包含C字母的元素全部删除
	}

增强for循环

java5.0版本之后推出了一个新特性，增强for循环，也称为新循环，该循环不同于传统的循环工作，只用于遍历数组和集合。

语法:

for (元素类型 e：集合或者数组){
	循环体;
}
新循环并非新语法，而是在编译过程中，编译器会将新循环转化为迭代器模式
所以可以说新循环的本质是迭代器

演示代码如下：

		public void testFor() {
			Collection<String> c = new HashSet<String>();
			c.add("java");
			c.add("c");
			c.add("php");
			c.add("c#");
			c.add("python");
			for (String string : c) {
				System.out.println(string.toUpperCase()+" ");
				//C# PYTHON JAVA C PHP
			}
	}

泛型机制

1.泛型机制是JavaSE 5.0引入的特性，泛型的本质是参数化类型，在类接口和方法的定义过程中，所操作的数据类型被传入的参数指定。

2.Java泛型机制广泛的应用在集合框架中，所有的集合类型都带有泛型参数，这样在创建集合时可以指定放入集合中元素的类型，java编译器可以据此类型进行检查，这样就可以减少代码在运行时出现的错误可能性。

3.ArrayList类的定义中，中的E为泛型参数，在创建对象时可以将类型作为参数传递，此时类定义所有的E将被替换成传入的参数。

演示代码如下：

	public void testE() {
		ArrayList<String> list = new ArrayList<String>();
		list.add("One");//只能添加String类型的数据
	}

集合操作-线性表

List

1.List接口是Collection的子接口，用于定义线性表数据结构，可以将List理解为存放对象的数组，只不过元素个数可以动态的增加或者减少。

2.List接口的两个常见实现类为ArrayList和LinkedList分别用动态数组和链表的方式实现了List接口

3.可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别。ArrayList更适合于随机访问，LinkedList更适合插入和删除。

常用方法

List除了继承Collection定义的方法外，还根据其线性表的数据结构定义了一系列的方法，其中最常用的就是基于下标的get和set方法。

E get(int index) 获取集合中指定下标对应的元素，下标从0开始
E set(int index,E element)将指定的元素存入指定的位置，并将原位置元素返回

演示代码如下：

	public void testGetAndSet() {
		List<String> list = new ArrayList <String>();
		list.add("java");
		list.add("c++");
		list.add("php");
		list.add("python");
		list.add("c#");
		//get方法遍历List
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i).toUpperCase());
			//JAVA C++ PHP PYTHON C#
		}
		String value = list.set(1, "hadoop");
		System.out.println(value);//c++
		System.out.println(list);//java hadoop php python c#
		//先拿到hadoop 将 hadoop插入索引3的位置 把python 返回，然后再把python插入索引1的位置
		list.set(1, list.set(3, list.get(1)));
		System.out.println(list);
		//java python php hadoop c#
	}

根据下标的操作进行插入和删除

void add(int index,E element)将给定的元素插入到指定位置，原位置以及后续
元素都顺序向后移动
E remove(int index):删除给定位置的元素，并将被删除的元素返回

演示代码如下：

	public void testInsertAndRemove() {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("c++");
		System.out.println(list);//java c++
		
		list.add(1,"cpp");
		System.out.println(list);//java cpp c++
		
		String a = list.remove(2);
		System.out.println(list+".."+a);//java cpp...c++
	}

获取子List(sublist)

注意sublist获取的List与原List占用相同存储空间，对子List的操作会影响原List
List<E>sublist(int fromIndex,int toIndex) fromIndex和toIndex是截取子
List的首尾下标，前包后不包。

演示代码如下：

	public void testSubList() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add(i);
		}
		System.out.println(list);//0-9
		
		List<Integer> sublist = list.subList(3, 8);//3 4 5 6 7
		//subList获得的List和源List占有相同的资源
		for (int i = 0; i < sublist.size(); i++) {
			sublist.set(i, sublist.get(i)*10);
		}
		System.out.println(sublist);//30 40 50 60 70
		//用的是同一块 存储空间 对子List操作会影响原List
		System.out.println(list);// 0 1 2 30 40 50 60 70 8 9
		//注意clear只能删除连续元素
		list.subList(3, 8).clear();
		System.out.println(list);// 0 1 2  8 9
	}

List与数组之间的转化

1.List的toArray方法用于将集合转化为数组，但实际上该方法是在collection的接口中定义的，所以所有的集合都具备这个功能。

Object[] toArray()
<T> T[] toArray(T[] a)
其中第二个方法是比较常用的，我们可以传入一个指定的类型的数组，该数组元素类型
一致。返回值是转换后的数组，该数组会保留集合中的所有元素

演示代码如下：

	public void testToArray() {
		List<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		String [] strArr = list.toArray(new String[] {});
		System.out.println(Arrays.toString(strArr));//[a,b,c]
	}

2.Arrays数组类中提供了一个静态方法asList 使用该方法我们可以将一个数组转化为对应的List集合

static <T> List<T> asList<T...a>
返回的List集合元素类型由传入的数组的元素类型决定
返回的集合我们不能对其增删元素，否则会抛出异常，并且对集合的元素进行修改
会影响数组对应的元素。

演示代码如下：

	public void testArrayToList() {
		String [] strArr = {"a","b","c"};
		List<String> list = Arrays.asList(strArr);
		System.out.println(list);
		//list.add("d");//抛出异常
		//System.out.println(list);
		List<String> list1 = new ArrayList<String>();
		list1.addAll(Arrays.asList(strArr));
		list1.add("d");
		System.out.println(list1);
		/*
		 * 数组转化为List是不能增删的 如果需要增删 可以利用空集合调用addAll方法将转换后的集合全部添加 新集合
		 * 	就可以进行操作了。
		 */
	}

List排序

1.Collections是集合的工具类，它提供了很多便于我们操作集合的方法，其中就有用于集合排序的sort方法

该方法定义为：
-void sort(List<T> list)
该方法的作用是对给定的集合元素进行自然排序

演示代码如下：

		public void testSort() {
		List<Integer> list = new ArrayList<Integer>();
		Random r = new Random();
		for (int i = 0; i <10;i++) {
			list.add(r.nextInt(100));
		}
		System.out.println(list);//[7, 77, 94, 15, 6, 83, 35, 30, 24, 49]
		Collections.sort(list);//从小到大排序
		System.out.println(list);//[6, 7, 15, 24, 30, 35, 49, 77, 83, 94]
	}

Comparable

Collections的sort方法是对集合的自然排序，那么两个元素对象之间就一定要分大小，这个大小之分是如何判断的呢？实际上在使用Collections的sort排序的集合元素都必须是Comparable接口的实现类。

该接口表示子类是可以比较的，因为实现接口必须重写抽象方法

int compareTo(T t);
该方法用于使当前对象与给定对象进行比较
若当前对象大于给定对象 返回值为大于0的整数
若当前对象小于给定对象	返回值为小于0的整数
若两个对象相等        则返回0

演示代码如下：

	public void testComparable() {
		/*
		 * Cell实现了Comparable 接口
		 * compareTo 方法逻辑为 按照x值大小进行排序
		 */
		List<Cell> cells = new ArrayList<Cell>();
		cells.add(new Cell(2,3));
		cells.add(new Cell(5,1));
		cells.add(new Cell(3,2));
		Collections.sort(cells);
		System.out.println(cells);
		2,3   3,2   5,1
	}

Comparator

1.一旦Java类实现了Comparable接口，其比较逻辑就已经确定，如果希望在排序的操作中，临时指定比较规则，可以采用Comparator接口回调的方式
2.Comparator 接口要求实现类必须重写其定义的方法：

int compare(T o1,T o2)
若o1>o2 方法的返回值应大于0
若o1<o2 方法的返回值应小于0
若o1=o2则返回0

演示代码如下：

		public void testComparator() {
		List<Cell> cells = new ArrayList<Cell>();
		cells.add(new Cell(2,3));
		cells.add(new Cell(5,1));
		cells.add(new Cell(3,2));
		//临时按照y排序 this.y-o.y
		Collections.sort(cells, new Comparator<Cell>() {
			@Override
			public int compare(Cell o1, Cell o2) {
				// TODO Auto-generated method stub
				return o1.y-o2.y;
			}
		});
		System.out.println(cells);//5,1 3,2 2,3
		//临时回调
		Collections.sort(cells);
		System.out.println(cells);//2,3 3,2 5,1
	}

比较总结

1.对于集合比较实用Collection.sort()

2.对于集合中的对象比较，需要指定比较逻辑，需要实现Comparable接口并重写compareTo方法自定义逻辑

3.对于需要临时改变比较规则，需要使用Collections.sort(List,Comparator)采用回调方式重写Comparator接口的compare方法自定义逻辑。

Queue和Deque

Queue

1.队列Queue是常用的数据结构，可以将队列看成特殊的线性表，队列限制了对线性表的访问方式，只能从线性表的一端添加元素(offer)从另一端取出(poll)元素

2.队列遵循先进先出的原则

3.JDK提供了Queue接口，同时使得LinkedList实现了该接口，选择LinkedList实现Queue接口的原因在于Queue经常要进行添加和删除的操作，而LinkedList在这方面效率比较高。

4.Queue接口主要方法如下：

boolean offer(E e):将一个对象添加至队尾，如果添加成功则返回true
E poll()：从队首删除并返回一个元素
E peek()：返回队首元素但是不删除

演示如下代码：

	public void testQueue() {
		Queue<String> queue = new LinkedList<String>();
		queue.add("a");
		queue.offer("b");
		queue.offer("c");
		System.out.println(queue);//a b c
		String str = queue.peek();
		System.out.println(str);//a
		String str1 = queue.poll();
		System.out.println(str1);//a
		System.out.println(queue);//b c
		
		while(!queue.isEmpty()) {
			str = queue.poll();
			//遍历只能用删除队首 poll方法 删除后队首元素会变为第二个元素 而peek不会改变队首元素
			System.out.println(str+" ");//b c
		}
	}

Deque

1.Deque是Queue的子接口，定义了所谓的双向队列。即从队列的两端分别可以入队(offer)和出队(poll)。LinkedList实现了该接口

2.如果将Deque限制为只能从一端入队和出队，则可实现栈 Stack 的数据接口
入栈称为push 出栈称为pop

3.栈遵循先进后出的原则

	public void testStack() {
		Deque<String> stack = new LinkedList<String>();
		stack.push("a");
		stack.push("b");
		stack.push("c");
		System.out.println(stack);//c b a
		String s = stack.peek();
		System.out.println(s);//c
		while(!stack.isEmpty()) {
			 s = stack.pop();
			 System.out.println(s+" ");// c  b  a
		}
		System.out.println(stack);//[]
	}
	}

Map接口

1.Map接口定义的集合又称之为查找表，用于存储所谓的"Key-Value"映射对。Key可以看成是Value的索引，作为key的对象在集合中不可以重复。

2.根据内部数据结构不同，Map接口有多种实现类，其中常用的有内部为hash表实现的HashMap和内部为排序二叉树实现的TreeMap

put()方法

1.Map接口中定义了向Map中存放元素的put方法

V put(K key,V value)

2.将key-value对存入Map，如果在集合中已经包含了该Key，则操作将替换该key所对应的value，返回值为该key原来所对应的value，如果没有包含该Key返回null。
演示代码如下：

	//创建成员变量
	Map<String,Person> persons = new HashMap<String,Person>();
	@Before //表示在每执行一次test就执行一次before
	public void testPut() {
		persons.put("张三", new Person("张三",80));
		persons.put("闫伟", new Person("闫伟",81));
		//System.out.println(persons);
	}

3.Map接口中定义了从Map中获取元素的get方法

V get(Object key)返回参数key所对应的value对象，如果不存在则返回null

演示代码如下：

	@Test
	public void testGet() {
		Person  p = persons.get("张三");
		System.out.println(p);//Person [name=张三, age=80]
	}

containsKey()方法

Map接口中定义了判断某个key是否在Map中存在

boolean containsKey(Object key)
若Map中包含给定的key则返回true

演示代码如下：

	@Test
	public void testContainsKey() {
		System.out.println(persons.containsKey("闫伟"));//true
	}

hashCode方法

1.从hashMap的原理中我们可以看到，key的hashCode()方法的返回值对HashMap存储元素时会起着
非常重要的作用，而hashCode()方法实际上是在Object中定义的

2.对于重写了equals方法的对象，一般要妥善的重写继承自Object类的hashCode方法
(Object提供的hashCode方法将返回该对象所在内存地址的整数形式)

3.重写hashCode方法应注意两点：

 		-与equals方法的一致性，即equals比较返回true的两个对象其hashCode方法返回值应该相同
 		-hashCode返回的数值应符合hash算法的要求，如果有很多对象的hashCode返回值都相同 则会大大降低
  			hash表的效率，一般情况下使用IDE eclipse提供的工具自动生成hashCode方法

装载因子及hashMap优化

1.Capacity:容量，hash表里bucket的数量也就是散列数组大小

2.Inintal capacity：初始容量，创建hash表时，初始bucket的数量，默认构建容量是16
也可以使用特定的容量

3.Size：大小，当前散列表中存储数据的数量

4.Load factor：加载因子默认值为0.75，当向散列表增加数据时如果size/capacity的值大于factor则扩容
并且重新散列(rehash)

5.性能优化：加载因子较小时散列查找性能会提高，同时也浪费了散列桶的容量。0.75是性能和空间相对平衡结果
在创建散列表时指定合理的容量，减少rehash提高性能

Map遍历

1.Map提供了三种遍历方式

遍历所有的key
遍历所有的key-value对
遍历所有的value---不常用

2.遍历所有key的方法

Set<K> keySet()
该方法返回当前Map中所有Key存入一个Set集合

演示代码如下：

	@Test
	public void testKeySet() {
		Set<String> keyset = persons.keySet();
		System.out.println(keyset);//[张三, 闫伟]
		for (String string : keyset) {
			System.out.println("key:"+string);
			/*
			 * key:张三
			 * key:闫伟
			 */
		}
	}

entrySet()方法遍历所有键值对

Set<Entry<k,v>> entrySet()
该方法将当前Map中的每一组key-value对封装为一个Entry对象并存入一个
Set集合返回

演示代码如下：

	public void testEntrySet() {
		Set<Entry<String,Person>> entrySet = persons.entrySet();
		//[张三=Person [name=张三, age=80], 闫伟=Person [name=闫伟, age=81]]
		System.out.println(entrySet);
		
		for (Entry<String, Person> entry : entrySet) {
			System.out.println(entry.getKey()+":"+entry.getValue());
			/*
			 * 张三:Person [name=张三, age=80]
			 * 闫伟:Person [name=闫伟, age=81]
			 */
		}
	}

有序的Map

1.使用Map接口的哈希表和链表实现，具有可预知迭代顺序，此实现与HashMap的不同之处在于：
LinkedHashMap维护着一个双向循环链表，此链表定义了迭代顺序，该迭代顺序通常就是存放元素的顺序。

2.需要注意，如果在Map中重新存入已有Key，那么key位置不会发生改变，改变的是value值。

演示代码如下：

	@Test
	public void testLinkedHashMap() {
		LinkedHashMap<String,Person> map = new LinkedHashMap<String,Person>();
		map.put("李志豪", new Person("李志豪",99));
		map.put("李四", new Person("李四",18));
		System.out.println(map);
		//{李志豪=Person [name=李志豪, age=99], 李四=Person [name=李四, age=18]}
		map.put("李四", new Person("李四",66));
		System.out.println(map);
		//{李志豪=Person [name=李志豪, age=99], 李四=Person [name=李四, age=66]}
	}

哈喽沃耳德

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java集合知识点详细概括加代码解释

集合Collection （List And Set）1.在实际开发中，需要将使用的对象存储于特定的数据结构容器中。JDK提供了这样的容器-集合(Collection)。2.Collection 是一个接口，其子接口有：List和Set3.List和Set的区别：List是有序可重复集（可以存储重复元素），Set是无序不可重复集（不能存储重复元素）。元素是否重复取决于元素的equals（）比...
复制链接

扫一扫