黑马程序员——java基础-集合

　------- android培训、java培训、期待与您交流！ ----------

  第一节：集合的概述
一、集合的简述：
1、集合的由来：
我们学习的是Java -->面向对象 -->操作很多对象 -->存储 -->容器(数组和StringBuffer) -->数组而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用
2、集合特点：
(1)、用于存储对象的容器。 
(2)、集合的长度是可变的。 
(3)、集合中不可以存储基本数据类型值。  
3、集合和数组的区别：
(1)、长度区别
数组固定
集合可变
(2)、内容区别
数组可以是基本类型，也可以是引用类型
集合只能是引用类型
(3)、元素内容
数组只能存储同一种类型
集合可以存储不同类型(其实集合一般存储的也是同一种类型)
二、集合的继承体系结构
由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。
Collection
|--List
|--ArrayList
|--Vector
|--LinkedList
|--Set
|--HashSet
|--TreeSet
第二节：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():取出元素的方式：迭代器。 
迭代器：
(1)、该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。所以该迭代器对象是在容器中进行内部实现的。   
(2)、对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可， 也就是iterator方法。
(3)、Iterator接口就是对所有的Collection容器进行元素取出的公共接口。把它可以想象成抓娃娃游戏机中的夹子！ 
5、其他： 
boolean retainAll(Collection coll);取交集。 
Object[] toArray():将集合转成数组。
第三节：List
一、简述：
1、有序的 collection（也称为序列）。
2、此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
3、用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
4、与 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); 根据元素获取第一次角标，否则返回-1
int lastIndexOf(object); 获取最后出现元素的角标
List subList(form,to);获取部分对象元素
注：有一个共性特点就是都可以操作角标
5、其他
ListIterator listIterator();获取特有的迭代器
迭代器：
(1)、并发修改异常
(1).1:出现的现象
迭代器遍历集合，集合修改集合元素
(1).2:原因
迭代器是依赖于集合的，而集合的改变迭代器并不知道。
(1).3:解决方案
(1).3.1:迭代器遍历，迭代器修改(ListIterator)
元素添加在刚才迭代的位置
(1).3.2:集合遍历，集合修改(size()和get())
元素添加在集合的末尾
(2)、ListIterator是List集合特有的迭代器，它是Iterator的子接口。
(3)、ListIterator的常用方法
void add(obj);增加
void set(obj);修改为obj
boolean hasPrevious();判断前面有没有元素
Object previous();取前一个元素
三、List子类的特点
1、ArrayList:
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
2、Vector:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
3、LinkedList:
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
四、集合ArrayList
1、此集合的没有特有的功能需要学习，因为它的功能与List一样。
2、案例
(1) ArrayList存储字符串并遍历，并保证元素的唯一性

//用list集合添加字符串 要保证元素的唯一性
/*
由于字符串中的equals来自object它只比较两个元素的地址值 没有比较两个元素。
1、创建一个list集合对象 添加元素 要有重复的元素
2、在创建一个新的集合对象 用迭代器进行对老的集合中的元素进行遍历 并且存储到新的集合当中去，在存储的过程当中如果遇到重复的就不存储了。
3、再把老集合清空
4、在把新集合中的元素添加到老集合当中去
5、清空老集合
6、再打印集合查看元素


*/
import java.util.*;
class Demo
{
	public static void main(String[] args)
	{
		//创建一个ArrayList类的对象
	ArrayList<String>list=new ArrayList<String>();
	//添加元素
	list.add("a");
	list.add("abc");
	list.add("a");
	//把数据传入函数中，并返回一个集合
	ArrayList<String>lis=getList(list);
	//打印集合中的元素
	System.out.println(lis);
	}
	public static ArrayList<String>getList(ArrayList<String> list)
	{
		//在创建一个集合
	ArrayList<String>list1=new ArrayList<String>();
	//对集合中的元素进行遍历
	for (String str:list)
	{
		//如果list1集合中不包含这个元素，就添加这个集合到list1集合当中去
		if (!list1.contains(str))
		{
			list1.add(str);
		}
	}
	//把list集合清空
	list.clear();
	//把list1集合中的元素全部添加到list集合中
	list.addAll(list1);
	//把list1集合进行清空
	list1.clear();
	//返回list集合
	return list;	
	}
}

(2) ArrayList存储自定义对象并遍历，并保证元素的唯一性

//在list集合当中添加自定义对象并且保证元素的唯一性
/*
思路：
1、写一个学生类 有姓名 年龄属性并覆盖toString方法和equals方法(保证元素的唯一性)
2、在main方法中创建学生类对象 并添加元素
3、看是否有重复元素

*/
import java.util.*;
class Demo1
{
	
	public static void main(String[] args)
	{
		//创建一个ArrayList类的对象
	ArrayList<Student>list=new ArrayList<Student>();
	//往集合中添加元素
	list.add(new Student("张三",23));
	list.add(new Student("小三",3));
	list.add(new Student("大三",13));
	list.add(new Student("中三",23));
	list.add(new Student("张三",23));
	//把集合传入到一个函数当中去，并把返回的机会赋值给list
	list=equals1(list);
	//打印list集合中的元素
	System.out.println(list);
	}
	public static ArrayList<Student>equals1(ArrayList<Student>list)
	{
		//在创建一个集合
		ArrayList<Student>lis=new ArrayList<Student>();
		//对集合中的元素进行遍历
		for(Student st:list)
		{
			//如果list1集合中不包含这个元素，就添加这个集合到list1集合当中去
			if (!(lis.contains(st)))
			{
				lis.add(st);
			}
		
		}
		//把list集合清空
		list.clear();
		//把lis集合中的元素全部添加到list集合中
		list.addAll(lis);
		//lis集合清空
		lis.clear();
	return list;
	}
	
	
}
//定义一个学生类
class Student
{
	//私有学生类的属性
	private String name;
	private int age;
	Student(String name,int age)
	{
	this.name=name;
	this.age=age;
	}
	//并提供对外访问方式
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//覆盖Object中的equals方法
	public boolean equals(Object obj)
	{
		if (this==obj)
		return true;
		//如果不是学生类就抛出异常
		if (!(obj instanceof Student))
		{
			throw new RuntimeException("类型转换异常");
		}
		//进行强转
		Student stu=(Student)obj;
		//进行比较如果是name与age都相同的话，就是同一个人
	return this.name.equals(stu.name)&&this.age==stu.age;
	}
	//覆盖Object中的toString方法
	public String toString()
	{
	return "name="+name+"......age="+age;
	}
}

五、集合Vector
1、特有的功能：
(1) 添加
void addElement(E obj) -->add()
(2) 获取
public E elementAt(int index) --> get()
public Enumeration<E> elements() -->  iterator()
2、枚举 Enumeration
(1)、它是Vector特有的获取方法，
(2)、枚举与迭代器的功能是一样的，由于它和方法的名称过长，就被迭代器代替了。
六、集合 LinkedList
1、特有的功能
(1) 添加
addFirst()
addLast()
jdk1.6 
offerFirst(); 
offetLast();
(2) 删除
removeFirst()获取并移除，如果链表为空，抛出NoSuchElementException. 
removeLast()
jdk1.6 
pollFirst();获取并移除，如果链表为空，返回null. 
pollLast(); 
(3) 获取
getFirst()获取但不移除，如果链表为空，抛出NoSuchElementException. 
getLast()
jdk1.6 
peekFirst();获取但不移除，如果链表为空，返回null. 
peekLast(): 
2、两种数据结构
(1)堆栈：先进后出 First In Last Out  FILO   
(2)队列：先进先出 First In First Out FIFO 
(3)用LinkedList来模拟一个堆栈或者队列数据结构。
代码体现

//自定义一个队列的结构
/*
思路：
1 先定义一个类 在构造函数当中创建一个List对象
2 在定义一个添加元素的方法
3 在定义一个一下获取元素的方法


*/
import java.util.*;
class Demo2
{
	public static void main(String[] args)
	{
		//创建队列类的元素
	Queu<String> q=new Queu<String>();
	//并添加元素
	q.add("张三");
	q.add("王五");
	q.add("李四");
	q.add("周七");
	q.add("赵八");
	//获取元素
	q.get();
	
	}
}
//自定一个队列类
class Queu<String>
{
	//把创建LinkedList集合的对象进行私有
	private LinkedList<String> list=list=new LinkedList<String>();
	//进行添加元素
	public void add(String str)
	{
		//用的是list对象的进行添加元素
		list.addLast(str);
	
	}
	//获取元素
	public void get()
	{
		//对集合中元素进行遍历并删除
		while (!list.isEmpty())
		{
			//并打印被删除的元素
			System.out.println(list.removeFirst());
		}
	
	}
}

3、在集合中常见的数据结构
  (1)ArrayXxx:底层数据结构是数组，查询快，增删慢
  (2)LinkedXxx:底层数据结构是链表，查询慢，增删快
  (3)HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
  (4)TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序
第四节：Set
一、简述：
1、不包含重复元素的集合，不保证顺序。
2、而且方法和Collection一致。
3、Set集合取出元素的方式只有一种：迭代器。
二、Set子类的特点
1、HashSet集合
(1)底层数据结构是哈希表(是一个元素为链表的数组)
(2)哈希表底层依赖两个方法：hashCode()和equals()
 执行顺序：
首先比较哈希值是否相同
相同：继续执行equals()方法
返回true：元素重复了，不添加
返回false：直接把元素添加到集合
不同：就直接把元素添加到集合
(3)如何保证元素唯一性的呢?
由hashCode()和equals()保证的
(4)开发的时候，代码非常的简单，自动生成即可。
(5)HashSet存储字符串并遍历，并且保证元素的唯一。

//保证hashSet集合的元素唯一
/*
思路：
1 定义一个hashset集合的对象 并添加元素
2 进行对集合遍历 看是否有重复元素
string类型已经覆盖了hashcode方法了和equals方法了

*/
import java.util.*;
class Demo3
{
	public static void main(String[] args)
	{
		//创建HashSet集合对象
	HashSet<String>hs=new HashSet<String>();
	//往集合中添加元素
	hs.add("a");
	hs.add("ab");
	hs.add("ab");
	hs.add("abc");
	//并对集合中的元素进行遍历
	for (String s:hs )
	{
		//打印集合中的元素
		System.out.println(s);
	}
	
	
	}
}

(6)HashSet存储自定义对象并遍历。并保证元素的唯一性。

//自定义一个类用hashset集合去存储要保证元素的唯一性
/*
1、自定义一个类有姓名 年龄 属性 并且要覆盖hashcode方法和equals方法
2、创建hashset集合的对象 并添加元素
3、取出元素看是否有重复


*/
import java.util.*;
class Demo4
{
	public static void main(String[] args)
	{
		//创建HashSet集合对象
		HashSet<Student>hs=new HashSet<Student>();
		//往集合中添加元素
		hs.add(new Student("张三",34));
		hs.add(new Student("周七",13));
		hs.add(new Student("李四",12));
		hs.add(new Student("李四",12));
		hs.add(new Student("赵六",54));
		hs.add(new Student("王五",21));
		//并对集合中的元素进行遍历
		for (Student st:hs)
		{
			//打印集合中的元素
			System.out.println(st);
		}
	
	}
}
//定义一个学生类
class Student
{
	//私有学生类的属性
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	//并提供对外访问方式
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//覆盖Object中的hashCode方法
	public int hashCode()
	{
	return name.hashCode()+age;
	}
	//覆盖Object中的equals方法
	public boolean equals(Object obj)
	{
		if (this==obj)
		return true;
			//如果不是学生类就抛出异常
		if (!(obj instanceof Student))
		{
			throw new RuntimeException("类型转换异常");
		}
			//进行强转
		Student stu=(Student)obj;
		//进行比较如果是name与age都相同的话，就是同一个人
		return this.name.equals(stu.name)&&this.age==stu.age;
	
	}
	//覆盖Object中的toString方法
	public String toString()
	{
	
	return "name="+name+"age="+age;
	}
}

2、TreeSet集合
(1)底层数据结构是红黑树(是一个自平衡的二叉树)
(2)保证元素的排序方式
(2).1自然排序(元素具备比较性)
让元素所属的类实现Comparable接口 覆盖CompareTo()方法
(2).2比较器排序(集合具备比较性)
让集合构造方法接收Comparator的实现类对象 覆盖Compare()方法
代码体现

1、对TreeSet集合进行遍历，并保证元素的唯一性

//创建TreeSet集合对象，并添加元素并保证元素的唯一性(String 类型)
/*
思路：
1、创建TreeSet集合对象并添加元素
2、取出集合中的元素

*/
import java.util.*;
class Demo5
{
	public static void main(String[] args)
	{
		//创建TreeSet集合对象
	TreeSet<String>set=new TreeSet<String>();
	//并添加元素
	set.add("a");
	set.add("ab");
	set.add("ac");
	set.add("ab");
	//用迭代器进行对集合中的元素遍历
	for (Iterator<String>irr=set.iterator();irr.hasNext() ; )
	{
		//打印集合中的元素
		System.out.println(irr.next());
	}
	
	}

}

2、TreeSet集合存储自定义对象并遍历，并保证元素的唯一性

//自定义一个类并创建TreeSet集合对象添加元素并保证元素的唯一性
/*
思路：
1、 自定义一个类实现Comparable接口 覆盖compareTo方法 并定义自己姓名年龄属性
2、创建集合Treeset对象 添加元素
3、取出元素看看元素是否唯一
4、有时比较的并不是我们想要的结果 这时我们自己可以自定义一个比较器Comparator接口覆盖compare方法
*/
import java.util.*;
class Demo6
{
	public static void main(String[] args)
	{
		//创建TreeSet集合对象的同时也传入一个比较器的对象
		TreeSet<Student> set=new TreeSet<Student>(new MyComparator());
		//往集合中添加元素
		set.add(new Student("张三",23));
		set.add(new Student("王五",13));
		set.add(new Student("赵六",3));
		set.add(new Student("赵六",3));
		set.add(new Student("李四",93));
		//用迭代器进行对集合中的元素遍历
		for (Iterator<Student>irr=set.iterator();irr.hasNext() ; )
		{
			//打印集合中的元素
			System.out.println(irr.next());
		}
	
	}
}
//自定义一个学生类并实现了Comparable接口
class Student implements Comparable<Student>
{
	//私有学生类的属性
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
		//并提供对外访问方式
	public String getName()
	{
	
	return name;
	}
	public int getAge()
	{
		return age;
	}
	//覆盖接口中的CompareTo方法
	public int compareTo(Student stu)
	{
		//看看name是否相同
		int temp=this.name.compareTo(stu.name);
		//当name和age相同时为同一个人
		return temp==0?this.age-stu.age:temp;
	}
	//覆盖Object中的toString方法
	public String toString()
	{
	return "name="+name+".....age="+age;
	}
}
//自定义一个比较器类并实现了Comparator接口
class MyComparator implements Comparator<Student>
{
	//覆盖compare方法
	public int compare(Student s,Student s1)
	{
		int temp=s1.getName().compareTo(s.getName());
		//当name和age都相同为同一人
		return temp==0?s.getAge()-s1.getAge():temp;
	}
}

第五节 Map集合
一、简述：
    1、将键映射到值的对象
    2、一个映射不能包含重复的键
    3、每个键最多只能映射到一个值
二、Map接口和Collection接口的不同
1、Map是双列的,Collection是单列的
2、Map的键唯一,Collection的子体系Set是唯一的
3、Map集合的数据结构值针对键有效，跟值无关
4、Collection集合的数据结构是针对元素有效
三、Map接口常见的功能
1、 添加功能
(1) V put(K key,V value);添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
        (2) v oidputAll(Map <? extends K,? extends V> m);添加一个集合
2、 删除功能
(1) void clear();清空
        (2) V remove(Object key);删除指定键值对
3、判断功能
(1) boolean containsKey(Object key);判断键是否存在
        (2) boolean containsValue(Object value)判断值是否存在
        (3) boolean isEmpty();判断是否为空
4、获取功能
(1)V get(Object key);通过键获取对应的值
(2)Collection<V>value();获取Map集合中所以得值，返回一个Collection集合
    5、长度功能
(1) int size();获取集合的长度
6、Map集合的遍历
(1)键找值 Set<K> keySet();
(1).1获取所有键的集合
(1).2遍历键的集合,得到每一个键
(1).3根据键到集合中去找值
(2)键值对对象找键和值 Set<Map.Entry<K,V>> entrySet();
(2).1获取所有的键值对对象的集合
(2).2遍历键值对对象的集合，获取每一个键值对对象
(2).3根据键值对对象去获取键和值
代码体现

//对Map集合中的元素进行存取 
/*
思路;
1、创建Map集合的对象并添加元素
2、map集合中没有迭代器 有个方法可以获取Set到集合 keySet方法  第二个获取他们之间的关系
3、在用迭代器进行获取键 有了键在根据map集合中的方法获取到值

*/
import java.util.*;
class Demo7
{
	public static void main(String[] args)
	{
		//创建TreeMap集合对象
		TreeMap<String ,Integer>map=new TreeMap<String,Integer>();
		//往集合中添加元素
		map.put("张三",23);
		map.put("王五",23);
		map.put("周七",23);
		//获取集合中的元素第一种方法
		getElement(map);
		//获取集合中的元素第二种方法
		getElement1(map);
	
	}
	public static void getElement1(TreeMap<String,Integer>map)
	{
		//调用TreeSet集合中的方法返回一个集合中键和值之间的关系
		Set<Map.Entry<String,Integer>> sett=map.entrySet();
		//就用迭代器进行对集合中键和值的关系遍历
		for (Iterator<Map.Entry<String,Integer>>irr=sett.iterator();irr.hasNext() ; )
		{
			//拿到每一个键和值的关系
			Map.Entry<String,Integer> meo=irr.next();
			//根据关系中的方法获取集合中的键
			String ss=meo.getKey();
			//然后再获取值
			Integer in=meo.getValue();
			//打印键和值
			System.out.println("key="+ss+"........value="+in);
		}
	
	}

	public static void getElement(TreeMap<String,Integer> map)
	{
		//调用TreeSet集合中的方法返回一个集合中键
		Set<String>set=map.keySet();
		//对集合中的键进行遍历
		for (Iterator<String>irr=set.iterator();irr.hasNext() ; )
		{
			//获取集合中的一个键
			String s=irr.next();
			//在根据键去获取与之对应的值
			System.out.println("key="+s+"......value="+map.get(s));
		}
	
	}
}

7、Map常用的子类特点： 
        |--Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。 
          |--Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。    
|--HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。 
|--TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。 
8、代码体现

//自定义一个类 创建这个类的对象添加到map集合中去并获取添加的每个元素
/*
思路：
1 自定义一个类 有姓名 年龄 
2 创建map集合对象并添加元素
3 在获取到集合中的元素

*/
import java.util.*;
class Demo8
{
	public static void main(String[] args)
	{
		//创建TreeMap集合对象
		TreeMap<Student,String>map=new TreeMap<Student,String>();
		//往集合中添加元素
		map.put(new Student("张三",23),"上海");
		map.put(new Student("王五",13),"北京");
		map.put(new Student("李四",3),"郑州");
		map.put(new Student("周期",93),"南京");
		//往函数中传入一个Map集合
		getElement(map);
	
	}
	public static void getElement(TreeMap<Student,String>map)
	{
		//调用TreeSet集合中的方法返回一个集合中键和值之间的关系
		Set<Map.Entry<Student,String>>set=map.entrySet();
		//就用迭代器进行对集合中键和值的关系遍历
		for (Iterator<Map.Entry<Student,String>>irr=set.iterator();irr.hasNext() ; )
		{
			//拿到每一个键和值的关系
			Map.Entry<Student,String>en=irr.next();
			//根据关系中的方法获取集合中的键
			Student stu=en.getKey();
			//然后再获取值
			String s=en.getValue();
			//打印键和值
			System.out.println("key="+stu+"............value="+s);
		}
	
	
	}
}
//自定义一个学生类并实现了Comparable接口
class Student implements Comparable<Student>
{
	//私有学生类的属性
	private String name;
	private int age;
	Student(String name,int age)
	{
	this.name=name;
	this.age=age;
	}
	//并提供对外访问方式
	public String getName()
	{
	return name;
	}
	public int getAge()
	{
		return age;
	}
	//覆盖接口中的CompareTo方法
	public int compareTo(Student stu)
	{
		//name之间进行比较
		int temp=this.name.compareTo(stu.name);
		return temp==0?this.age-this.age:temp;
	}
	//覆盖Object中的toString方法
	public String toString()
	{
	
	return "name="+name+"..........age="+age;
	}

}

   ------- android培训、java培训、期待与您交流！ ----------

最后

以上就是时尚发箍为你收集整理的黑马程序员——java基础-集合的全部内容，希望文章能够帮你解决黑马程序员——java基础-集合所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。