Java集合(全家桶)

一,Collection集合概述:

(1)集合是存储其他对象的特殊对象。可以将集合当做一个容器。

(2)集合的相关接口和类位于java.util包中。

(3)集合中的接口和类是一个整体、一个体系。

集合优点:数据类型不统一,长度不固定。

 

二,集合接口:

集合框架定义了一些接口,它们决定了集合类的本质特性。具体的集合类只是提供了标准接口的不同实现。

注意:

1、Collection接口中没有提供修改元素的方法。

2、Collection接口的父接口是Iterable接口,实现了Iterable接口的类是可以迭代的。

接  口

描  述

Collection

允许操作一组对象,它位于集合层次结构的顶部

List

扩展Collection,以处理序列(对象列表)

Deque

扩展Queue,以处理双端队列

Set

扩展Collection,以处理组,组中的元素必须唯一

集合类:

描  述

ArrayList

动态数组

LinkedList

链表

ArrayDeque

双端队列 = 队列 + 堆栈

PriorityQueue

支持基于优先级的队列

HashSet

使用哈希表存储元素的组

LinkedHashSet

扩展HashSet类,以允许按照插入的顺序进行迭代

TreeSet

实现存储于树中的集合。

三,Collection常用的子接口:

Collection是集合类最大的父接口,下面是它的子接口(实现类):


 

List

List集合:分为Arraylist,Linkedlist与Vector。

ArrayList:

      基于数组, 查询效率高, 增加, 删除效率低, 线程不同步。

 ArrayList实现了List接口。本质上是元素为对象引用的长度可变的数组

ArrayList常用方法如下:

package listdemo;
import java.util.List;
import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		//泛型:参数化类型==》类型参数化  JDK1.5之后
		List<String> list=new ArrayList<String>();
		//Element=》元素-E
		
		//向集合中添加数据=>追加  add(元素)  
		list.add("One");  //Integer
		
		list.add("Two");  //Integer
		list.add("Three");  //Integer
		
		//插入 操作  add(插入位置,插入元素);
		list.add(1,"我");
		
		//通过下标查找  get(下标)  通过下标找元素
//		String string = list.get(2);
		
		//集合元素个数的   size()
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		//删除元素  通过下标删除元素 remove(下标)
//		list.remove(2);
		//删除元素   通过元素内容进行删除  remove(元素)
		System.out.println("============================");
//		Integer ii=31;
//		list.remove("我");
		
		//修改    set(修改的位置,修改后的内容)
//		list.set(2, "WTO");
//		for(int i=0;i<list.size();i++){
//			System.out.println(list.get(i));
//		}
		
		//clear  清空集合
//		list.clear();
		
		//isEmpty()  是否为空集合  如果集合中没有元素  返回true
		System.out.println(list.size()+"=="+list.isEmpty());
	}
}

 

ArrayList集合的循环遍历,如下:

 

package cam;

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

public class Demo {
	
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("One");
		list.add("Two");
		list.add("Three");
		list.add("Four");

	
		//第一种List 集合的循环遍历方法
		//1:集合个数,2:get方法
		//掌握程度*   最好理解的写法
//		for(int i=0;i<list.size();i++){
//			System.out.println(list.get(i));
//		}
		
		//第二种List 集合的循环遍历方法  
		//增强for循环  也称之为foreach 循环 
		//for(元素的数据类型   名:集合/数组对象){}
		//写法最简单   ***
//		for(String s:list){
//			System.out.println(s);
//		}
		
		//第三种List 集合的循环遍历方法
		//Iterator 迭代器
		//生成迭代器   *****
		Iterator<String> it=list.iterator();
		//it.hasNext() 代表  是否存在下一个 元素
		//it.next()     将下一个元素返回  并且指针下一(指针人为定义)
		//it.remove()	迭代器  remove方法 
		while(it.hasNext()){
			String str =it.next();
			if(str.equals("Three")){
				it.remove();
//				list.remove("Three");  
				//break;
				//使用迭代器删除操作  不要使用集合的删除  建议使用迭代器的删除,
				//如果使用集合的删除操作    必须使用break
			}
		}
	}
	
    

LinkedList:

基于链表, 查询效率低, 增加, 删除效率高, 线程不同步。

     

LinkedList类实现了List、Deque以及Queue接口。

它提供了(双向)链表数据结构。

具体实现就不写了,下面写一些它的常用方法:

 注:List 接口中所有的方法 ,LinkedList 也存在。

LinkedList独有的方法:

1,addFirst() 添加到集合的首部

2,addLast() 添加到集合的尾部

3,getFirst(); 获取第一个元素

4,getLast()  获取最后一个元素

5,removeFirst(); 删除第一个元素

6,removeLast() 删除最后一个元素

ArrayList与LinkedList的区别:

1、ArrayList是基于数组结构的集合,有容量的概念;LinkedList是基于链表结构的集合,没有容量的概念

2、对于随机访问(get和set方法),ArrayList优于LinkedList,因为LinkedList要移动指针。

3、对于新增和删除操作(add和remove方法),LinkedList比较占优势,因为ArrayList要移动数据。但是如果只是在末尾追加元素,并且没有超出容量限制,则ArrayList的性能更好。

4、LinkedList 还实现了Queue接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等。            

 Vector: 

       限制线程同步的一个线程安全的list集合。Stack是Vector的子类,Stack与Vector一样,是线程安全的,但是性能较差,尽量少用Stack类。如果要实现栈”这种数据结构,可以考虑使用LinkedList。按照原来长度的2倍扩容。

Set

Set集合 :是一个无序且不可重复的集合:分为HashSet,TreeSet与LinkedHashSet。

HashSet:

         基于HashCode 码实现

HashSet类实现了Set接口。该类在内部使用哈希表存储元素。

哈希表使用称之为散列法(hashing)的机制存储信息。

希法的优点是add()、contains()、remove()以及size()方法的执行时间保持不变,即使是对于比较大的集合也是如此。HashSet()  //默认容量是16。

HashSet中元素不是按有序的顺序存储的,遍历输出HashSet中的元素时精确的输出可能不同。

HashSet实现测试,如下:

package cbm;

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

public class SetTest {
	public static void main(String[] args) {
		//创建Set 集合
		//HashSet  是基于HashCode 码 进行排列的
		Set  set=new HashSet();
		//添加 add();
		//当出现 重复的元素  返回false 代表不允许添加重复元素
//		boolean f1 = set.add("你好");
//		boolean f2 = set.add("你好");
//		boolean f3 = set.add("你好");
//		set.add(" ");
//		set.add("");
//		set.add(null);
//		System.out.println(f1);
//		System.out.println(f2);
//		System.out.println(f3);
		
		//清空集合 clear()
		
		//contains 是否包含指定元素
//		boolean contains = set.contains("你");
//		System.out.println(contains);
				
		//是否为空  isEmpty();
		
		//删除元素 remove(元素);  Set集合本身是无序所以没有下标
//		boolean remove = set.remove("你好");
//		System.out.println(set.isEmpty());
//		size() 获取集合元素的个数
//		System.out.println(set.size());
		
//		Iterator it = set.iterator();
//		while(it.hasNext()){
//			Object o=it.next();
//			System.out.println(o);
//		}		
	}
}

TreeSet:

       基于二叉树实现,最大的特点就是元素会按照自然顺序排序。

TreeSet类实现了NavigableSet接口,该类在内部使用树结构存储元素。元素以升序存储,访问和检索相当快。

TreeSet适合于存储大量的、必须能够快速查找到的有序信息。

Set与List的区别:

1、Set中的元素不能重复,List中的元素可以重复。
2、List有索引(下标)的概念,Set没有索引的概念。
3、对于Set表示的集合,通常是遍历操作,没有get()和set()方法。

注意:

TreeSet以升序保存对象,所以TreeSet中保存的对象比较能够比较大小,即TreeSet保存的对象类型必须实现Comparable接口。

package cbm;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class SetTest1 {

	public static void main(String[] args) {
		Student s1 = new Student(12,"张三");
		Student s2 = new Student(14,"李四");
		Student s3 = new Student(1,"王五");
		Student s4 = new Student(25,"赵六");
		//使用TreeSet 添加的元素的数据类型 必须实现Comparable 比较器
		Set<Student>  set=new  TreeSet<Student>();
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);
		Iterator<Student> it = set.iterator();
		while(it.hasNext()){
			Student s=it.next();
			System.out.println(s);
		}
	}
	
}

//学生类
package cbm;

public class Student implements Comparable{
	
	private int age;
	private String name;
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Student(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}
	
	//比较器的方法
	@Override
	public int compareTo(Object o) {
		Student s=(Student)o;
		if(s.getAge()>this.getAge()){
			return -1;
		}
		return 1;
	}

//了解
	//Set中 比较相同的方法是equals,HashCode 码是否相同
	@Override
	public boolean equals(Object obj) {
		Student  s=(Student)obj;
		if(s.getName().equals(this.getName())&&s.getAge()==this.getAge())
		return true;
		return false;
	}
	
	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		return 1;
	}
}

LinkedHashSet类:

      扩展了HashSet类,它没有添加它自己的方法。

LinkedHashSet在内部使用一个链表维护元素添加到集合中的顺序,因此可以按照插入顺序迭代集合。

下面是对一些实现方法:

package cbm;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class SetTest2 {

	public static void main(String[] args) {
		//LinkedHashSet Set集合中唯一有插入顺序的集合
		LinkedHashSet<String> lhs=new LinkedHashSet<String>();
//		HashSet<String> lhs=new HashSet<String>();
		lhs.add("你好");
		lhs.add("我好");
		lhs.add("大家好");
		lhs.add("都好,都好");
		
		Iterator<String> it = lhs.iterator();
		while(it.hasNext()){
			String next = it.next();
			System.out.println(next);
		}
	}
}

注意:Set类型的集合(实现Set接口的类)称为集,有些资料称为组,其特点是组中的元素必须唯一。

HashSet是无序的,LinkedHashSet和TreeSet是有序的。

四,遗留的集合类与接口 

在集合之前,Java提供了特定的类,存储和管理对象组,例如Dictionary、Vector、Stack和Properties。

早期版本的java.util包没有包含集合框架。反而,定义了几个类和接口,提供存储对象的专门方法。当添加集合时(由J2SE 1.2添加),对几个原始类进行了重新设计,以支持集合接口。因此,从技术上讲它们现在是集合框架的组成部分。

前面介绍的所有现代集合类都不是同步的,但是所有遗留类都是同步的。

1 ,Vector

现在Vector类实现了动态数组,与ArrayList类似,也实现List接口。但有如下区别:

l  Vector实现同步,线程安全。ArrayList没有实现线程安全。

l  Vector性能比ArrayList低。

l  Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间(2n),而ArrayList每次对原长度增加1.5倍加1(公式:oldLength+oldLength/2+1,即:每一次增加1.5倍)。

2, Hashtable

Hashtable类也实现了Map接口,与HashMap类似。

主要区别:

1、Hashtable是同步的、线程安全的,而HashMap不是同步的,没有实现线程安全。

2、HashMap允许将null作为一个条目的key或者value,而Hashtable不允许。当然只能有一个条目的键为null。

3、HashMap把Hashtable的contains方法去掉了,改成containsvalue和containsKey。因为contains方法容易让人引起误解。

五,比较特殊的集合:Map集合(这里只介绍HashMap)

HashMap基本方法:

package cbm;

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

public class MapTest {

	public static void main(String[] args) {
		Map<String,String> map=new HashMap<String,String>();
//      从增删改查xueqi   
//		增加  put(键,值)
//		map.put("One", "壹");
		//增加
//		map.put("Two", "贰");
		
		//查寻	 get(键);  通过键找到值
//		String s=map.get(11);
//		System.out.println(s);
		
		//删除  remove(键)  通过键删除键与值的映射关系  返回 原有的value的值
//		String  sss=map.remove("Two");
//		System.out.println(sss);
		
//		System.out.println(map.get("Two"));
		
//		map.put("Two","叁");
		
		//clear() 清空集合
		//size()  map 集合的键值关系数
		//isEmpty()  当前集合是否为空集合  size 是否为0;
//		System.out.println(map.size());
//		map.clear();
//		System.out.println(map.size());
		
		//当前集合是否包含某一个键 containsKey
//		boolean ck = map.containsKey("壹");
//		System.out.println(ck);
		
		//当前集合是否包含某一个值containsValue
//		boolean cv = map.containsValue("One");
//		System.out.println(map.get("Two"));
//		System.out.println(cv);
	}
}

Map集合遍历方法:

package cbm;

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

public class MapTest1 {

	public static void main(String[] args) {
		Map<String,String> map=new HashMap<String,String> ();
		map.put("One", "壹");
		map.put("Two", "贰");
		map.put("Three", "叁");
		map.put("Four", "肆");
		
		//遍历第一种方式
		//map 遍历本身没有迭代器  需要一个有迭代器的集合接收 map 对象的元素
		//这个set 集合中存放着map 集合的键
		//keySet()  将 map 集合对象的键 放入一个新的Set 集合对象中
		//*****
//		Set<String> set=map.keySet();
//		for(String s:set){
//			String key=s;
//			String value=map.get(key);
//			System.out.println(key+"====="+value);
//		}
		
		//遍历第二种方式  直接遍历值
		//如果单纯遍历值  可以使用 values 方法
		//返回的结果 不是Set 集合而是Collection集合
//		Collection<String> cl = map.values();
//		Iterator<String> it = cl.iterator();
//		while(it.hasNext()){
//			String value = it.next();
//			System.out.println(value);
//		}
		
		//遍历第三种方式  将键与值 一次性取出  
		//**
		Set<Entry<String, String>> set = map.entrySet();
		Iterator<Entry<String, String>> it = set.iterator();
		while(it.hasNext()){
			Entry<String, String> en = it.next();
			System.out.println(en.getKey()+"========"+en.getValue());
		}
	}
}

 

更多相关Map集合的知识点击进入“映射篇”。

                                                   

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值