Java 集合框架

2021-01-10 02:31

阅读：566

标签：存储方式链表 eal tor more lse element vat 对象

一、集合框架

1.数组和集合都是容器，两者有什么区别呢？

数组长度是固定的，数组可以存储对象，可以存储基本数据类型。

集合长度是可变的，集合只能存储对象。

2.为什么出现这么多容器呢？

因为每一个容器对数据的存储方式不一样，这个存储方式被称为数据结构。

二、常用方法

2.1 增加、删除

import  java.util.*;

/*
1，add方法的参数类型是Object。以便接收任意类型对象。
2，集合中存储的都是对象的引用（地址）。
*/
public class CollectionTest {
	public static void main(String[] args) {
		//创建一个集合容器，使用Collection接口的子类:Arraylist。
		ArrayList al = new ArrayList();
		
		//1.添加元素
		al.add("java01"); //add(Object o);
		al.add("java02");
		al.add("java03");
		al.add("java04");
			
		//2.获取个数。集合长度。
		System.out.println("size:"+al.size());
		
		//3.删除元素。
		al.remove("java01");
		//al.clear();
		
		//4.判断元素
		System.out.println("java03是否存在:" + al.contains("java03"));
		System.out.println("al是否为空:" + al.isEmpty());
		
		//打印集合。
		System.out.println(al);
	}
}

运行结果：
size:4
java03是否存在:true
al是否为空:false
[java02, java03, java04]

2.2 取交集、差集

public static void method1() {
	ArrayList al1 = new ArrayList();
	al1.add("java01");
	al1.add("java02");
	al1.add("java03");
	al1.add("java04");
	
	ArrayList al2 = new ArrayList();
	al2.add("java01");
	al2.add("java02");
	al2.add("java07");
	al2.add("java08");
	
//	al1.retainAll(al2); //取交集，al1中只会保留与al2中相同的元素。
//	System.out.println(al1);
//	System.out.println(al2);
	
	al1.removeAll(al2);
	System.out.println(al1);
	System.out.println(al2);
}

retainAll运行结果：
[java01, java02]
[java01, java02, java07, java08]
removeAll运行结果：
[java03, java04]
[java01, java02, java07, java08]

2.3 元素的取出

public void get_method() {
	ArrayList al = new ArrayList();
	al.add("java01");
	al.add("java02");
	al.add("java03");
	al.add("java04");
	
	Iterator it = al.iterator(); //迭代器
	
	while(it.hasNext()) {
		System.out.println(it.next());
	}
}

运行结果：
java01
java02
java03
java04

或者也可以这样写：

 for(Iterator it = al.iterator();it.hasNext();) {
	System.out.println(it.next());
}

三、List

3.1 list常见操作

package com.collection;

/*
 * Collection
 * 	|--List:元素有序。元素可以重复。因为该集合体系有索引。
 * 	|--Set:元素无序。元素不可以重复。
 * 
 * List：
 * 	特有方法：凡是可以操作角标的方法都是该体系特有的方法。
 * 
 * 	增：
 * 		add(index,element);
 * 		addAll(index,Collection);
 * 	删:
 * 		remove(index);
 * 	改:
 * 		set(index,element);
 * 	查:
 * 		get(index);
 * 		subList(from,to);
 * 		listIterator();
 * */

import java.util.*;

public class ListDemo {

	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		
		al.add("java01");
		al.add("java02");
		al.add("java03");

		System.out.println("原集合是："+al);	//原集合是：[java01, java02, java03]
		
		//在指定位置添加元素
		al.add(1, "java8");
		System.out.println("在指定位置添加元素后："+al);	//在指定位置添加元素后：[java01, java8, java02, java03]
		
		//删除指定位置的元素
		al.remove(2);
		System.out.println("删除指定位置的元素后："+al);	//删除指定位置的元素后：[java01, java8, java03]
		
		//修改元素
		al.set(1, "java007");
		al.add("java009");
		al.add("java009");
		al.add("java009");
		System.out.println("修改元素后："+al); 	//修改元素后：[java01, java007, java03, java009, java009, java009]
		
		//通过角标获取元素
		System.out.println("获取元素："+al.get(1));		//获取元素：java007
		
		//获取所有元素
		for(int i=0; i

3.2 列表迭代器

import java.util.*;

public class ListDemo {

	public static void main(String[] args) {
		//演示列表迭代器
		ArrayList al = new ArrayList();
		
		al.add("java01");
		al.add("java02");
		al.add("java03");
		
		Iterator it = al.iterator();
		
//		while(it.hasNext()){
//			System.out.println(it.next());
//		}
		
		//在迭代过程中准备添加或者删除元素
		while(it.hasNext()){
			Object obj = it.next();
			if(obj.equals("java02"))
				al.add("java000");
			
			System.out.println("obj = " + obj);
		}
	}
}

运行结果：
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at com.collection.ListDemo.main(ListDemo.java:44)
obj = java01
obj = java02

并发修改异常。
在用迭代器操作时，又用了集合的操作。

3.2.1 使用迭代器操作（局限性：只能删除）

//在迭代过程中准备添加或者删除元素
while(it.hasNext()){
	
	Object obj = it.next();
	
	if(obj.equals("java02"))
		it.remove();	//将java02的引用从集合中删除
	
	System.out.println("obj = " + obj);
}
System.out.println(al);

运行结果：
obj = java01
obj = java02
obj = java03
[java01, java03]

3.2.2 ListIterator

/*
 * List集合特有的迭代器：ListIterator。
 * ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素。
 * 因为会发生ConcurrentModificationException异常。
 * 
 * 所以，在迭代时，只能使用迭代器的方法操作元素。
 * 可是Iterator方法有限，只能对元素进行判断、取出、删除的操作。
 * 如果想要其他操作，比如添加、修改等，就需要使用其子接口，ListIterator。
 * 
 * 该接口只能通过List集合的listIterator()方法调用。
 * */

public static void main(String[] args) {
	//演示列表迭代器
	ArrayList al = new ArrayList();
	
	al.add("java01");
	al.add("java02");
	al.add("java03");
	al.add("java008");
	
	ListIterator li = al.listIterator();
	while(li.hasNext()){
		Object obj = li.next();
		
		if(obj.equals("java02"))
			li.add("java009");
	}
	System.out.println(al);
}

运行结果：
[java01, java02, java009, java03, java008]

3.2.3 ListIterato API

技术图片

3.3 List常见的子类对象

/*
 * Collection
 * 	|--List:元素有序。元素可以重复。因为该集合体系有索引。
 * 		|--ArrayList : 底层数据结构是数组结构。	特点：查询、修改速度很快。增加、删除速度很慢。 线程不同步。
 * 		|--LinkedList ： 底层数据结构是链表结构。	特点：增删速度很快，查询稍慢。
 * 		|--Vector ： 底层是数组数据结构。线程同步。被ArrayList替代了。
 * 
 * 	|--Set:元素无序。元素不可以重复。
 * 
 * */

3.4 Vector

/* 
 * 枚举是Vector特有的取出方式。
 * 枚举和迭代器很像。 
 * 
 * 其实枚举和迭代器一样。
 * 因为枚举的名称和方法名都过长，所以被迭代器取代。
 * */
public class VectorDemo {

	public static void main(String[] args) {
		Vector v = new Vector();
		v.add("java01");
		v.add("java02");
		v.add("java03");
		
		Enumeration en = v.elements();
		
		while(en.hasMoreElements()){
			System.out.println(en.nextElement());
		}
	}

}

3.5 LinkedList

3.5.1 LinkedList特有方法

package com.collection;

import java.util.*;
/*
 * LinkedList特有方法：
 * addFirst(E e);
 * addLast(E e);
 * 
 * getFirst();
 * getLast();
 * 获取元素但不删除元素。如果集合中没有元素，NoSuchElementException。
 * 
 * removeFirst();
 * removeLast();
 * 获取元素删除元素。如果集合中没有元素，NoSuchElementException。
 * 
 * 在JDK1.6出现了替代方法
 * offerFirst(E e);
 * offerLast(E e);
 * 插入元素
 * 
 * peekFirst(); 
 * peekLast(); 
 * 检索但不删除元素。如果此列表为空，则返回 null 。
 * 
 * pollFirst();
 * pollLast();
 * 检索并删除元素。如果此列表为空，则返回 null 。 
 * */
public class LinkedListDemo {

	public static void main(String[] args) {
		LinkedList link = new LinkedList();
		link.addFirst("java01");
		link.addFirst("java02");
		link.addFirst("java03");
		link.addFirst("java04");
		
		System.out.println(link);	//[java04, java03, java02, java01]
		System.out.println(link.getFirst());	//java04
		System.out.println(link.getLast());	//java01
		
		System.out.println(link.removeFirst());	//java04
		System.out.println(link);	//[java03, java02, java01]
		
		while(!link.isEmpty()){
			link.removeFirst();
		}
	}
}

3.5.1 LinkedList练习

import java.util.*;

/*
 * 使用LinkedList模拟堆栈或者队列数据结构
 * 
 * 堆栈：先进后出。如同杯子。
 * 队列：先进先出。如同水管。
 * 
 * */
public class LinkedListTest {

	public static void main(String[] args) {
		Queue q1 = new Queue();
		q1.myAdd("java01");
		q1.myAdd("java02");
		q1.myAdd("java03");
		q1.myAdd("java04");
		
		while(!q1.isNull()){
			System.out.println(q1.myGet());
		}
	}

}

class Queue{
	private LinkedList link;
	
	Queue(){
		link = new LinkedList();
	}
	
	public void myAdd(Object obj){
		link.addFirst(obj);
	}
	
	public Object myGet(){
		return link.removeLast();
	}
	
	public boolean isNull(){
		return link.isEmpty();
	}
}

3.5.2 LinkedList API

技术图片

3.6 ArrayList

import java.util.*;

/*
 * 去除ArrayList集合中的重复元素
 * */
public class ArrayListTest {

	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add("aaa");
		al.add("bbb");
		al.add("bbb");
		al.add("def");
		al.add("ggg");
		singleElement(al);	//[aaa, bbb, def, ggg]
	}

	public static void singleElement(ArrayList al){
		//定义一个临时容器
		ArrayList al1 = new ArrayList();
		
		ListIterator li = al.listIterator();
		while(li.hasNext()){
			Object obj = li.next();
			if(al1.indexOf(obj) == -1){
				al1.add(obj);
			}
		}
		
		System.out.println(al1);
	}
}

import java.util.*;

/*将自定义对象存入ArrayList中，并删除重复元素*/
public class ArrayListTest2 {

	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add(new Person("张三",20));
		al.add(new Person("李四",25));
		al.add(new Person("王五",21));
		al.add(new Person("李四",25));
		
		ArrayList newAl = singleElement(al);
		
		Iterator it = newAl.iterator();
		while(it.hasNext()){
			Person p = it.next();
			System.out.println(p.getName() + "::" + p.getAge());
		}
	}

	public static ArrayList singleElement(ArrayList al){
		//定义一个临时容器
		ArrayList al1 = new ArrayList();
		
		ListIterator li = al.listIterator();
		
		while(li.hasNext()){
			Object obj = li.next();
			if(!al1.contains(obj)){
				al1.add(obj);
			}
		}
		
		return al1;
	}
}

class Person{
	private String name;
	private int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public boolean equals(Object obj){
		if(!(obj instanceof Person))
			return false;
		 Person p = (Person)obj;
		 return p.name.equals(this.name) && p.age == this.age;
	}
}

运行结果：
张三::20
李四::25
王五::21

contains实际上是调用对象的equals方法。

技术图片

结论：

List集合判断元素是否相同，依据的是元素的equals方法。

其他：

remove、indexof底层其实用的也是元素的equals方法。

技术图片

ArrayList API

技术图片

Java 集合框架

标签：存储方式链表 eal tor more lse element vat 对象

原文地址：https://www.cnblogs.com/jszfy/p/12953106.html

上一篇：判断一个数组里面的所有键所对应的值是否是为int型

下一篇：Python爬淘宝商品信息

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：Java 集合框架
文章链接：http://soscw.com/index.php/essay/41297.html

亲，登录后才可以留言！

Java 集合框架

一、集合框架

1.数组和集合都是容器，两者有什么区别呢？

2.为什么出现这么多容器呢？

二、常用方法

2.1 增加、删除

2.2 取交集、差集

2.3 元素的取出

三、List

3.1 list常见操作

3.2 列表迭代器

3.2.1 使用迭代器操作（局限性：只能删除）

3.2.2 ListIterator

3.2.3 ListIterato API

3.3 List常见的子类对象

3.4 Vector

3.5 LinkedList

3.5.1 LinkedList特有方法

3.5.1 LinkedList练习

3.5.2 LinkedList API

3.6 ArrayList

ArrayList API

评论

热门文章

推荐文章

最新文章

置顶文章