黑马程序员-----集合

最新推荐文章于 2022-11-29 13:49:05 发布

lewis_zhs

最新推荐文章于 2022-11-29 13:49:05 发布

阅读量295

点赞数 1

分类专栏： java-基础的学习文章标签：集合

本文链接：https://blog.csdn.net/lewis_zhs/article/details/45025301

版权

java-基础的学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

集合

集合概述

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

一、Collection

Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。

所属关系：

Collection

|--List//元素是有序的，元素可以重复。因为该集合体系有索引。

|--Set//元素是无序的，元素不可以重复。

Collection接口中的常见操作

1、添加元素

add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。

2、删除元素

remove(Objectobj);

removeAll(另一集合);//调用者只保留另一集合中没有的元素。

clear();//清空集合

3、判断元素

contains(Objectobj);//判断是否存在obj这个元素

isEmpty();//是否为空

4、获取个数，集合长度

size();

5、取交集

retainAll(另一集合);//调用者只保留两集合的共性元素。

注：集合中存储的都是对象的引用（地址）。

二、迭代

1、什么是迭代

迭代是取出集合中元素的一种方式。

对于集合的元素取出这个动作：

当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。

而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容：判断和取出。那么就可以将这些共性抽取。

那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方法：iterator();，来获取集合的取出对象。

因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

2、迭代的常见操作

hasNext();//有下一个元素，返回真

next();//取出下一个元素

remove();//移除

注：在迭代时循环中next调用一次，就要hasNext判断一次。

使用：

ArrayList a=newArrayList();//创建一个集合

Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。

第一种打印方式：

for(Iterator iter = a.iterator();iter.hasNext(); )

{

System.out.println(iter.next());

}

第二种打印方式：

Iteratoriter = a.iterator();

while(iter.hasNext())

{

System.out.println(iter.next());

}

3、迭代注意事项

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object，所以要记得类型转换。

一部分List

一、List

组成

List：元素是有序的，元素可以重复。因为该集合体系有索引。

|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

List的特有方法

凡是可以操作角标的方法都是该体系特有的方法。

1、增加

booleanadd(index,element);//指定位置添加元素

BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素

2、删除

Booleanremove(index);//删除指定位置的元素

3、修改

set(index,element);//修改指定位置的元素。

4、查找

get(index);//通过角标获取元素

subList(from,to);//获取部分对象元素

5、其他

listIterator();//List特有的迭代器

indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1

注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

二、ListIterator

1、概述

ListIterator是List集合特有的迭代器，是Iterator的子接口。

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

2、ListIterator特有的方法

add(obj);//增加

set(obj);//修改为obj

hasPrevious();//判断前面有没有元素

previous();//取前一个元素

三、LinkedList

LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

特有方法：

1、增加

addFirst();

addLast();

2、获取

//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

getFirst();

getLast();

3、删除

//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

在JDK1.6以后，出现了替代方法。

1、增加

offFirst();

offLast();

2、获取

//获取元素，但是不删除。如果集合中没有元素，会返回null。

peekFirst();

peekLast();

3、删除

//获取元素，并删除元素。如果集合中没有元素，会返回null。

pollFirst();

pollLast();

import java.util.LinkedList;

public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList l = new LinkedList();
		l.addFirst("java01");
		l.addFirst("java02");
		l.addFirst("java03");
		l.addFirst("java04");
		l.addFirst("java05");

		// 堆栈输出先进后出
		stack(l);
		System.out.println();
		l.addFirst("hello01");
		l.addFirst("hello02");
		l.addFirst("hello03");
		l.addFirst("hello04");
		l.addFirst("hello05");
		// 队列输出先进先出
		queue(l);

	}

	// 堆栈
	public static void stack(LinkedList l) {
		while (!l.isEmpty()) {
			sop(l.removeFirst());
		}
	}

	// 队列
	public static void queue(LinkedList l) {
		while (!l.isEmpty()) {
			sop(l.removeLast());
		}
	}

	// 输出
	public static void sop(Object obj) {
		System.out.print(obj + "\t");
	}
}

运行结果：

java05	java04	java03	java02	java01	
hello01	hello02	hello03	hello04	hello05

四、枚举Enumeration

枚举：

就是Vector特有的取出方式。Vector有三种取出方式。

其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

特有方法：

addElement(obj);//添加元素，相当于add(obj);

Enumerationelements();//Vector特有取出方式(枚举)

hasMoreElements();//相当于Iterator的hasNext()方法

nextElements();//相当于Iterator的next()方法

import java.util.Enumeration;
import java.util.Vector;

public class Demo1 {
	public static void main(String[]args){
		String s ="123";
		String ss = "bc";
		String sss = "abcdefg";
		Vector v=new Vector(); 
		v.addElement(s);
		v.add(ss);
		v.add(sss);
	    for(Enumeration e=v.elements();e.hasMoreElements();)  
	{  
	    System.out.println(e.nextElement());  
	    
	} 
	    v.remove(2);
	    for(Enumeration e=v.elements();e.hasMoreElements();)  
		{  
		    System.out.println(e.nextElement());  
		    
		} 
	}
		

}

运行结果：

123
bc
abcdefg
123
bc

二部分set

一、概述

Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。

|--HashSet：底层数据结构是哈希表。线程不同步。保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。

|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。

Set集合的功能和Collection是一致的。

二、HasSet

HashSet：线程不安全，存取速度快。

可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

import java.util.HashSet;
import java.util.Iterator;
//往hashSet集合中存入自定对象 
//姓名和年龄相同为同一个人，重复元素。去除重复元素 
//思路：1、对人描述，将人的一些属性等封装进对象 
//      2、定义一个HashSet容器，存储人对象 
//      3、取出 

public class HashSetDemo {
	public static void main(String[] args) {

		HashSet<Person> h = new HashSet<Person>();
		h.add(new Person("LiLei", 10));
		h.add(new Person("Ann", 6));
		h.add(new Person("Lucy", 30));
		h.add(new Person("Lily", 10));
		h.add(new Person("Tom", 10));

		getOut(h);

	}

	// 取出元素
	public static void getOut(HashSet<Person> h) {
		for (Iterator it = h.iterator(); it.hasNext();) {
			Person p = (Person) it.next();
			sop(p.getName() + "..." + p.getAge());
		}
	}

	// 打印
	public static void sop(Object obj) {
		System.out.println(obj);
	}

}

class Person {
	private String name;
	private int age;

	public Person() {

	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public boolean equals(Object obj) {// 复写equals方法
		if (!(obj instanceof Person))
			return false;
		Person p = (Person) obj;
		return this.name.equals(p.name) && this.age == p.age;
	}

	public int hashCode() {// 复写hashCode的方法
		return this.name.hashCode() + this.age;
	}
}

运行结果：

Tom...10
LiLei...10
Ann...6
Lucy...30
Lily...10

三、TreeSet

1、特点

a）底层的数据结构为二叉树结构

b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。

java中的很多类都具备比较性，其实就是实现了Comparable接口。

注意：排序时，当主要条件相同时，按次要条件排序。

c）保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Student> t = new TreeSet<Student>();
		t.add(new Student("hello1", 12));
		t.add(new Student("helloj", 2));
		t.add(new Student("hellodj", 12));
		t.add(new Student("hellosd", 12));
		t.add(new Student("hellowo", 22));

		for (Iterator<Student> it = t.iterator(); it.hasNext();) {
			Student s = it.next();
			System.out.println(s.getName() + "....." + s.getAge());
		}
	}

}

class Student implements Comparable {
	private String name;
	private int age;

	public Student() {

	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public boolean equals(Object obj) {// 复写equals方法
		if (!(obj instanceof Person))
			return false;
		Student s = (Student) obj;
		return this.name.equals(s.name) && this.age == s.age;
	}

	public int hashCode() {// 复写hashCode的方法
		return this.name.hashCode() + this.age;
	}

	// 复写compareTo以便TreeSet集合调用
	public int compareTo(Object obj) {
		Student s = (Student) obj;
		if (this.age == s.age)
			return this.name.compareTo(s.name);
		return this.age - s.age;
		// return new Integer(this.age).compareTo(new Integer(s.age));
	}
}

三部分Map

一、概述

Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）

特点：

1）该集合存储键值对，一对一对往里存

2）要保证键的唯一性。

二、Map集合的子类

Map

|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。

|--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。

|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。

Map和Set很像。其实Set底层就是使用了Map集合。

三、Map集合的常用方法

1、添加

Vput(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。

voidputAll(Map <? extends K,? extends V> m);//添加一个集合

2、删除

clear();//清空

Vremove(Object key);//删除指定键值对

3、判断

containsKey(Objectkey);//判断键是否存在

containsValue(Objectvalue)//判断值是否存在

isEmpty();//判断是否为空

4、获取

Vget(Object key);//通过键获取对应的值

size();//获取集合的长度

Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合

还有两个取出方法，接下来会逐个讲解：

Set<Map.Entry<K,V>>entrySet();

Set<K> keySet();

注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

四、Map集合的两种取出方式

Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。

1、Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。

package collection;

//每一个学生都有对应的归属地。 
//学生Student，地址String。 
//学生属性：姓名，年龄。 
//注意：姓名和年龄相同的视为同一个学生。 
//保证学生的唯一性。 
// 
//思路：1、描述学生类 
//      2、定义一个Map集合，存储学生对象和地址值 
//      3、获取Map中的元素 
//  

import java.util.*;

public class hashMapDemo {
	public static void main(String[] args) {
		HashMap<Student1, String> hm = new HashMap<Student1, String>();
		hm.put(new Student1("Lucy", 12), "beijing");
		hm.put(new Student1("Lucy", 32), "sahnghai");
		hm.put(new Student1("Lucy", 22), "shenzhen");
		hm.put(new Student1("Lucy", 62), "guangzhuo");
		hm.put(new Student1("Lucy", 12), "tianjing");

		keyset(hm);
	}

	// keySet取出方式
	public static void keyset(HashMap<Student1, String> hm) {
		Iterator<Student1> it = hm.keySet().iterator();

		while (it.hasNext()) {
			Student1 s = it.next();
			String addr = hm.get(s);
			System.out.println(s + ":" + addr);
		}
	}

}

// 描述学生类
class Student1 implements Comparable<Student1> {
	private String name;
	private int age;

	public Student1() {

	}

	public Student1(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	// 复写hashCode
	public int hashCode() {
		return name.hashCode() + age * 33;
	}

	// 复写equals，比较对象内容
	public boolean equals(Object obj) {
		if (!(obj instanceof Student1))
			throw new ClassCastException("类型不匹配");
		Student1 s = (Student1) obj;
		return this.name.equals(s.name) && this.age == s.age;
	}

	// 复写compareTo,以年龄为主
	public int compareTo(Student1 c) {
		int num = new Integer(this.age).compareTo(new Integer(c.age));
		if (num == 0) {
			return this.name.compareTo(c.name);
		}
		return num;
	}

	// 复写toString，自定义输出内容
	public String toString() {
		return name + "..." + age;
	}

}

2、Set<Map.Entry<K,V>> entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry

其实，Entry也是一个接口，它是Map接口中的一个内部接口。

关于Map.Entry：

Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？

原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。

b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

lewis_zhs

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-----集合

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------集合集合概述面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。集合只用于存储对象，集合长度是可
复制链接

扫一扫