集合框架

最新推荐文章于 2023-07-28 17:16:02 发布

wu_zz

最新推荐文章于 2023-07-28 17:16:02 发布

阅读量194

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/wu_zz/article/details/54563564

版权

Java 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

package cn.itcast.p3.collection.demo;

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

public class CollectionDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Collection coll = new ArrayList();
		
//		show(coll);
		
		Collection c1 = new ArrayList();
		Collection c2 = new ArrayList();
		show(c1,c2);
		
	}
	
	public static void show(Collection c1,Collection c2){
		
		//给c1添加元素。
		c1.add("abc1");
		c1.add("abc2");
		c1.add("abc3");
		c1.add("abc4");
		
		//给c2添加元素。
		c2.add("abc1");
		c2.add("abc2");
		c2.add("abc3");
		c2.add("abc4");
		c2.add("abc5");
		
		System.out.println("c1:"+c1);
		System.out.println("c2:"+c2);
		
		//演示addAll
		
//		c1.addAll(c2);//将c2中的元素添加到c1中。
		
		
		//演示removeAll
//		boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。
//		System.out.println("removeAll:"+b);
		
		//演示containsAll
//		boolean b = c1.containsAll(c2);
//		System.out.println("containsAll:"+b);
		
		//演示retainAll
		boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。
								//和removeAll功能相反 。
		System.out.println("retainAll:"+b);
		System.out.println("c1:"+c1);
		
		
	}
	
	public static void show(Collection coll){
		
		//1,添加元素。add.
		coll.add("abc1");
		coll.add("abc2");
		coll.add("abc3");
		System.out.println(coll);
		
		
		//2，删除元素。remove
//		coll.remove("abc2");//会改变集合的长度 
		
		//清空集合.
//		coll.clear();
		
		System.out.println(coll.contains("abc3"));
		
		
		System.out.println(coll);
		
	}

}

package cn.itcast.p3.collection.demo;

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

public class IteratorDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Collection coll = new ArrayList();
		coll.add("abc1");
		coll.add("abc2");
		coll.add("abc3");
		coll.add("abc4");
		
//		System.out.println(coll);
		
		//使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
//		Iterator it = coll.iterator();		
//		while(it.hasNext()){
//			System.out.println(it.next());
//		}
		
		for(Iterator it = coll.iterator(); it.hasNext(); ){
			System.out.println(it.next());
		}
		
//		System.out.println(it.next());
//		System.out.println(it.next());
//		System.out.println(it.next());
//		System.out.println(it.next());
//		System.out.println(it.next());//java.util.NoSuchElementException
		
	}

}

集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。
就使用集合容器进行存储。

集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。

集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。

框架的顶层Collection接口：

Collection的常见方法：

1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):

2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();

3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。

4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
其实就是抓娃娃游戏机中的夹子！

5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。

-------------------------------
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。

List:特有的常见方法：有一个共性特点就是都可以操作角标。

1，添加
void add(index,element);
void add(index,collection);

2，删除；
Object remove(index):

3，修改：
Object set(index,element);

4，获取：
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from,to);

list集合是可以完成对元素的增删改查。

List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

LinkedList:

addFirst();
addLast():
jdk1.6
offerFirst();
offetLast();

getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6
peekFirst();//获取但不移除，如果链表为空，返回null.
peekLast():

removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6
pollFirst();//获取并移除，如果链表为空，返回null.
pollLast();

Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。

LinkedHashSet可以使元素有序存放

|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。

TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。

if(this.hashCode()== obj.hashCode() && this.equals(obj))

哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。

2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。

注意：如果哈希值不同，是不需要判断equals。

二叉树：

package cn.itcast.p4.list.demo;

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

public class ListDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		List list = new ArrayList();
		show(list);
	}

	public static void show(List list) {
		
		//添加元素
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		System.out.println(list);
		
		//插入元素。		
//		list.add(1,"abc9");
		
		//删除元素。
//		System.out.println("remove:"+list.remove(2));
		
		//修改元素。
//		System.out.println("set:"+list.set(1, "abc8"));
		
		//获取元素。
//		System.out.println("get:"+list.get(0));
		
		//获取子列表。
//		System.out.println("sublist:"+list.subList(1, 2));
		
		
		System.out.println(list);
		
		
	}

}

package cn.itcast.p4.list.demo;

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


public class ListDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		List list = new ArrayList();
//		show(list);
		
		
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		
		System.out.println("list:"+list);
		ListIterator it = list.listIterator();//获取列表迭代器对象
		//它可以实现在迭代过程中完成对元素的增删改查。
		//注意：只有list集合具备该迭代功能.
		
		
		while(it.hasNext()){
			
			Object obj = it.next();
			
			if(obj.equals("abc2")){
				it.set("abc9");
			}
		}
//		System.out.println("hasNext:"+it.hasNext());
//		System.out.println("hasPrevious:"+it.hasPrevious());
		
		
		while(it.hasPrevious()){
			System.out.println("previous:"+it.previous());
		}
		System.out.println("list:"+list);
		
		
		
		
		
		/*Iterator it = list.iterator();
		while(it.hasNext()){
			
			Object obj = it.next();//java.util.ConcurrentModificationException
							//在迭代器过程中，不要使用集合操作元素，容易出现异常。
						//可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。 
			
			if(obj.equals("abc2")){
				list.add("abc9");
			}
			else
				System.out.println("next:"+obj);
		}
		System.out.println(list);
		*/
		
		
		
		
		
		
		
		
		
		
		
	}

	public static void show(List list) {
		
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		list.add("abc4");
		
		Iterator it = list.iterator();
		while(it.hasNext()){
			System.out.println("next:"+it.next());
		}
		
		//list特有的取出元素的方式之一。
		
		for(int x=0; x<list.size(); x++){
			System.out.println("get:"+list.get(x));
		}
	}

}

package cn.itcast.p2.linkedlist.test;

import java.util.LinkedList;

public class DuiLie {
	private LinkedList link;

	public DuiLie() {
		link = new LinkedList();
	}

	/**
	 * 队列的添加元素的功能。
	 */
	public void myAdd(Object obj) {
		link.addLast(obj);
	}

	public Object myGet() {
		return link.removeFirst();
	}

	public boolean isNull() {
		return link.isEmpty();
	}
}

package cn.itcast.p2.linkedlist.test;

import java.util.ArrayList;


/*
 * 请使用LinkedList来模拟一个堆栈或者队列数据结构。
 * 
 * 堆栈：先进后出 First In Last Out  FILO
 * 
 * 队列：先进先出 First In First Out FIFO
 * 
 * 我们应该描述这样一个容器，给使用提供一个容器对象完成这两种结构中的一种。
 */


public class LinkedTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		DuiLie dl = new DuiLie();
		
		dl.myAdd("abc1");
		dl.myAdd("abc2");
		dl.myAdd("abc3");
		dl.myAdd("abc4");
		
		while(!dl.isNull()){
			System.out.println(dl.myGet());
		}
		
		
	}

}

package cn.itcast.p3.arraylist.test;

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

import cn.itcast.p.bean.Person;

/*
 * 定义功能去除ArrayList中的重复元素。
 */

public class ArrayListTest2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		
//		demo();
		
//		singleDemo();
		
		
		ArrayList al = new ArrayList();
		al.add(new Person("lisi1",21));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		al.add(new Person("lisi4",24));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		System.out.println(al);
		
		al = getSingleElement(al);
		
		
		System.out.println(al.remove(new Person("lisi2",22)));
		System.out.println(al);
		
		
		
		
	}

	/**
	 * 
	 */
	public static void singleDemo() {
		ArrayList al = new ArrayList();
		al.add("abc1");
		al.add("abc2");
		al.add("abc2");
		al.add("abc1");
		al.add("abc");
		System.out.println(al);
		
		al = getSingleElement(al);
		
		System.out.println(al);
		
		
	}

	public static ArrayList getSingleElement(ArrayList al) {
		
		//1,定义一个临时容器。
		ArrayList temp = new ArrayList();
		
		//2,迭代al集合。
		Iterator it = al.iterator();
		
		while(it.hasNext()){
			Object obj = it.next();
			
			//3,判断被迭代到的元素是否在临时容器存在。
			if(!temp.contains(obj)){
				temp.add(obj);
			}
		}
		
		return temp;
	}

	/**
	 * 
	 */
	public static void demo() {
		
//		al.add(5);//al.add(new Integer(5));
	}
	

}

Map：一次添加一对元素，collection一次添加一个元素

Map也称为双列集合，collection集合称为单列集合

其实map集合中存储的就是键值对

map集合中必须保证键的唯一性

1.添加

value put(key，value)：返回前一个和key关联的值，如果没有返回null

2.删除

void clear（）；清空map集合

value remove（key）；根据指定的key翻出这个键值对

3.修改

boolean contains（key）；

boolean containsValue（value）；

boolean isEmpty（）；

4.获取

value get（key）；通过建获取值，如果没有该键返回null

当然可以通过返回null，来判断是否包含指定键

int size（）；获取键值对的个数

通过Map转成Set就可以迭代，找到了另一个方法，entrySet，该方法将键和值的映射关系作为对象存储到了Set集合中。而这个映射关系的类型就是Map.entry类型（结婚证）

======================================================================================================

集合的一些技巧：

需要唯一吗？

需要：set

需要制定顺序：

需要：TreeSet

不需要：HashSet

但是想要一个和存储一致的顺序（有序）：LinkedHashSet

不需要：List

需要频繁增删吗？

需要：LinkedList

不需要：ArrayList

如何记录每一个容器的结构和所属体系呢？

看名字：

List：

ArrayList

LinkedList

Set：

HashSet

TreeSet

后缀名就是该集合所属的体系

前缀名就是该集合的数据结构

看到array：就要想到数组，就要想到查询快，有角标

看到link：就要想到链表，就要想到增删快，就要想到add get remove first last的方法

看到hash：就要想到hash表，就要想到唯一性，就要想到元素需要覆盖hashcode和equals方法

看到tree：就要想到二叉树，就要想到排序，就要想到comparable，comparator

而且通常这些常用的集合容器都是不同步的

Map常用的子类：

Hashtable：内部结构是哈希表，是同步的。不允许null作为键，null作为值

properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合

HashMap：内部结构是哈希表，是不同步的，允许null作为键，null作为值

TreeMap：内部结构是二叉树，不是同步的，可以对Map集合中的键进行排序

======================================================================================================

Collections：集合框架的工具类

里面的方法都是静态的

给非同步的集合加锁

==================================================================

函数的可变参数：

其实就是一个数组，但是接收的是数组的元素

自动将这些元素封装成数组，简化了调用者的书写

注意：可变参数类型，必须定义在参数列表的结尾

======================================================================

foreach语句：
格式：

for（类型变量： Collection集合 | 数组）

{

}

传统for和高级for的区别？

传统for可以完成对语句执行很多次，因为可以定义控制循环的增量和条件

高级for是一种简化形式，它必须有被遍历的目标，该目标要么是数组，要么是collection单列集合

对于数组的遍历如果仅仅是获取数组中的元素，可以使用高级for

如果要对数组的角标进行操作建议使用传统for

wu_zz

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
集合框架

package cn.itcast.p3.collection.demo;import java.util.ArrayList;import java.util.Collection;public class CollectionDemo { /** * @param args */ public static void main(String[] args) { Co
复制链接

扫一扫