黑马程序员—集合框架

来源：互联网发布：室内设计有什么软件编辑：程序博客网时间：2024/05/20 14:15

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

集合(Collection)概述：

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

实现Collection接口的类： List子接口(List子接口的具体实现类ArrayList LinkList Vector)

Set子接口类(Set子接口的具体实现类HashSet TreeSet)

下面介绍一下collection 接口的常用成员方法：

添加功能的方法：

boolean add(E e) 把给定的数据添加到集合中

Collection c = new ArrayList();

删除功能的方法：

void clear() ：将集合中的元素清空

boolean remove(Object o): 将给定的元素在集合中删除

长度功能的方法：

int size() 返回集合中元素的个数

判断功能的方法：

boolean contains(Object o)判断当前集合中是否包含给定的元素

boolean isEmpty() 判断当前集合中的元素是否为空

转换功能的方法：

Object[] toArray()：把集合转换成数组

包含上面所有成员方法的简单应用 :

public class CollectionDemo2 {

public static void main(String[] args) {

//创建集合对象

Collection c = new ArrayList();

//boolean add(E e) 把给定的数据添加到集合中

c.add("hello");

c.add("Java");

c.add("JavaEE");

c.add(12345);

c.add(false);

//void clear() ：将集合中的元素清空

//c.clear();

//boolean remove(Object o) 返回值为boolean 类型

boolean flag = c.remove("hello");

System.out.println(flag);

boolean flag1 = c.remove("world");

System.out.println(flag1);

//int size() 返回集合中元素的个数

int count = c.size();

System.out.println(count);

//boolean contains(Object o)判断当前集合中是否包含给定的元素

boolean flag2 = c.contains("Java");

System.out.println(flag2);

boolean flag3 = c.contains("java");

System.out.println(flag3);

//boolean isEmpty() 判断当前集合中的元素是否为空

boolean flag4 = c.isEmpty();

System.out.println(flag4);

System.out.println(c);

//Object[] toArray()：把集合转换成数组并遍历

Object[] objArray = c.toArray();

for (int i = 0; i < objArray.length; i++) {

System.out.println(objArray[i]);

}

//介绍专属于集合的遍历方法

遍历功能(迭代器):

Iterator<E> iterator(): 遍历集合中的元素

Iterator中的方法：

boolean hasNext()如果仍有元素可以迭代，则返回 true。

Object next() 返回迭代的下一个元素。

public class CollectionDemo {

public static void main(String[] args) {

//创建集合对象

Collection c = new ArrayList();

//把字符串对象添加到集合

c.add("天坛");

c.add("天安门");

c.add("颐和园");

//遍历迭代器对象，用来遍历当前集合

Iterator it = c.iterator();

//判断有没有下一个元素可以迭代 boolean hasNext();

while (it.hasNext()) {

//迭代器获取获取元素的方法 .next();返回迭代的下一个元素

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

}

List接口概述：

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

List接口的特有方法:

void add(int index, E element) ：在当前集合中指定位置添加给定的元素

Object get(int index) 返回集合中指定位置的元素。

int indexOf(Object o)返回此集合中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

E remove(int index)移除列表中指定位置的元素（可选操作）。

E set(int index, E element)用指定元素替换列表中指定位置的元素

ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。

List接口特有方法的简单运用:

public class ListDemo {

public static void main(String[] args) {

//创建List集合对象

List list = new ArrayList();

//添加元素

list.add("hello1");

list.add("hello2");

//void add(int index, E element)

list.add(1, "hello3");

//Object get(int index) 返回集合中指定位置的元素。

Object obj = list.get(1);

//System.out.println("obj:"+obj);

//int indexOf(Object o)返回此集合中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

//int index = list.indexOf("Hello3");

int index = list.indexOf("hello3");

//System.out.println("index:"+index);

//Object remove(int index)移除集合中指定位置的元素

//Object obj2 = list.remove(1);

//System.out.println(obj2);

//E set(int index, E element)用指定元素替换集合中指定位置的元素

Object old = list.set(1, "hello3333333");

System.out.println("old:" + old);

//显示结果

System.out.println(list);

}

List集合中的特有方法：

ListIterator listIterator() 返回此集合元素的列表迭代器（按适当顺序）。

public class ListIteratorDemo2 {

public static void main(String[] args) {

//创建集合对象

List list = new ArrayList();

//添加元素到集合

list.add("hello1");

list.add("java");

list.add("hello3");

// 使用List集合特有的迭代器

ListIterator lit = list.listIterator();

while (lit.hasNext()) {

//获取集合中的元素

String s = (String)lit.next();

//判断

if ("java".equals(s)) {

//添加元素

//list.add("Android");//错误

lit.add("Android");

}

System.out.println(list);//[hello1, java, Android, hello3]

}

ArrayList 实现接口的具体类:

ArrayList 概述:底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

ArrayList常用的方法就是实现了Collection 和 List 接口中的方法(上面介绍过)；

ArrayList 的三种遍历方式:

第一种:Collection集合中的iterator()方法进行迭代器遍历

第二种:List集合中特有的listIterator()方法进行迭代器遍历

第三种:for循环(size() 与 get(int index) )

第一种:Iterator 迭代器遍历使用

hasNext();next() 配合while (){} 完成遍历

public class ArrayListDemo {

public static void main(String[] args) {

//创建集合对象

ArrayList list = new ArrayList();

//添加字符串元素到集合

list.add("Hello");

list.add("Java");

list.add("hehe");

//iterator方法

Iterator iterator = list.iterator();

while (iterator.hasNext()) {

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

}

第二种遍历方式ListIterator

public class ArrayListDemo {

public static void main(String[] args) {

// 创建集合对象

ArrayList list = new ArrayList();

// 添加字符串元素到集合

list.add("Hello");

list.add("Java");

list.add("hehe");

// 遍历

ListIterator<String> li = list.listIterator();

while (li.hasNext()) {

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

}

第三中for循环 size();get(int index)方法

public class ArrayListDemo {

public static void main(String[] args) {

//创建集合对象

ArrayList list = new ArrayList();

//添加字符串元素到集合

list.add("Hello");

list.add("Java");

list.add("hehe");

//遍历

for (int i =0; i<list.size(); i++) {

//获取到每一个元素，打印

System.out.println( list.get(i) );

}

Vector类概述：

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

Vector特有方法

public void addElement(Object obj)添加元素到集合相当于List中 add(Obejct obj)

public Object elementAt(int index) 返回集合中给定位置上的元素相当于List中

get(int index)

public Enumeration elements()返回此向量的组件的枚举相当于List中iterator()

boolean hasMoreElements()相当于iterator中hasNext()

Object nextElement()相当于iterator中next();

用一个案例完成上面方法的应用：

public class VectorDemo {

public static void main(String[] args) {

//创建集合对象

Vector v = new Vector();

//添加元素到集合

//v.add("hello");

v.addElement("hello");

v.addElement("world");

//遍历

//size() 与 get()

for (int i = 0; i < v.size(); i++) {

System.out.println( v.elementAt(i) );

}

//迭代器

Enumeration en = v.elements();

//判断是否有下一个元素

while (en.hasMoreElements()) {

//获取下一个元素

System.out.println( en.nextElement() );

}

LinkedList类概述：

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

LinkedList集合特有方法

public void addFirst(Object e)将指定元素插入此列表的开头

public void addLast(Object e)将指定元素添加到此列表的结尾。

public Object getFirst()返回此列表的第一个元素

public Object getLast()返回此列表的最后一个元素。

public Object removeFirst()移除并返回此列表的第一个元素。

public Object removeLast()移除并返回此列表的最后一个元素。

public class LinkedListDemo {

public static void main(String[] args) {

//创建集合对象

LinkedList list = new LinkedList();

//添加元素

list.add("JavaSE");

//public void addFirst(Object e)

list.addFirst("JavaEE");

//public void addLast(Object e)

list.addLast("Android");

//public Object getFirst()

System.out.println("getFirst:"+ list.getFirst());

//public Object getLast()

System.out.println("getLast:"+ list.getLast());

System.out.println("-------------------------");

//public Object removeFirst()

//Object obj = list.removeFirst();

//System.out.println("obj:"+obj);

//public Object removeLast()

Object obj = list.removeLast();

System.out.println("obj:"+obj);

//显示

System.out.println(list);

}

Set接口概述：

Set接口实现类HashSet TreeSet LinkedHashSet

一个不包含重复元素的 collection（集合）即元素的唯一性。

Set集合实现添加元素,遍历的小案例:

public class SetDemo {

public static void main(String[] args) {

// 创建集合对象

Set<String> set = new HashSet<String>();

// 添加元素到集合

set.add("Java");

set.add("平面设计");

set.add("游戏开发");

set.add("IOS");

// 遍历集合

System.out.println(set);

// 遍历方式只有两种:a) 迭代器 iterator();b)增强for()遍历

// 不可行 --> 普通for() size()与get() 因为通过查看API发现Set中没有 get()方法

for (String str : set) {

System.out.println(str);

}

// 迭代器遍历

Iterator<String> it = set.iterator();

while (it.hasNext()) {

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

;

}

HashSet类概述:

1:不保证 set 的迭代顺序。

2:特别是它不保证该顺序恒久不变。

HashSet如何保证元素唯一性：

底层数据结构是哈希表(元素是链表的数组)；

哈希表依赖于哈希值存储；

添加功能底层依赖两个方法：

int hashCode()

boolean equals(Object obj)

注意：使用HashSet集合存储自定义对象，自定义类中需要重写重写 hashCode() 与 equals()方法来保证元素的唯一性。

下面用两个案例来说明存储字符串和自定义对象。

存储字符串案例：

public class HashSetDemo {

public static void main(String[] args) {

// 创建HashSet集合对象

HashSet<String> set = new HashSet<String>();

// 添加字符串对象到集合

set.add("Java");

set.add("IOS");

set.add("Android");

// 遍历

for (String str : set) {

System.out.println(str);

}

存储自定义对象：

自定义类：重写hashCode() 与 equals()方法来保证元素的唯一性。

public class Person {

private String name;

private int age;

public Person() {

super();

// TODO Auto-generated constructor stub

}

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;

}

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + "]";

}

* @Override public int hashCode() { return 0; }

//重写hashCode(); 方法

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + age;

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

//重写equals();方法

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Person other = (Person) obj;

if (age != other.age)

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

public class HashSetTest {

public static void main(String[] args) {

//2:创建HashSet集合对象

HashSet<Student> set = new HashSet<Student>();

//3：创建元素对象

Student s1 = new Student("曹操");

Student s2 = new Student("刘备");

Student s3 = new Student("孙权");

Student s4 = new Student("孙权");

//4：添加元素到集合

set.add(s1);

set.add(s2);

set.add(s3);

set.add(s4);

set.add(s5);

//遍历

for (Student s : set) {

System.out.println(s.getName());

}

LinkedHashSet:

它是HashSet的子类

有序(元素存与取顺序一致)

底层存储：哈希表结构加上链表结构

通过哈希表结构保证LinkedHashSet元素唯一;通过链表结构保证元素有序

线程不同步--不安全-- 效率高

案例:

public class LinkedHashSetDemo {

public static void main(String[] args) {

//创建集合对象

LinkedHashSet<String> set = new LinkedHashSet<String>();

//添加元素

set.add("张三");

set.add("李四");

set.add("王五");

//遍历

for (String s : set) {

System.out.println(s);

}

TreeSet类概述：

使用元素的自然顺序对元素进行排序。

或者根据创建 set 时提供的 Comparator 进行排序。

具体取决于使用的构造方法。

底层使用的是二叉树结构，所以不用重写 HashCode 和 equals方法。

Comparator比较器接口（排序方法）：

方法：int compare(T o1,T o2)比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

案例：

public class TreeSetDemo3 {

public static void main(String[] args) {

// 创建集合对象

TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {

// 用来进行两个对象比较大小

@Override

public int compare(Student s1, Student s2) {

// 年龄

int num = s1.getAge() - s2.getAge();

// 姓名

int result = (num == 0) ? (s1.getName().compareTo(s2.getName()))

: num;

return result;

}

});

// 3：创建元素对象

Student s1 = new Student("w悟空", 28);

Student s3 = new Student("w悟空", 28);

Student s2 = new Student("b八戒", 18);

Student s4 = new Student("s沙师弟", 18);

// 4：添加元素到集合

ts.add(s1);

ts.add(s2);

ts.add(s3);

ts.add(s4);

// 5：遍历

for (Student s : ts) {

System.out.println(s.getName() + "--" + s.getAge());

}

//自定义类:不需要重写 HashCode 和 equals方法。

public Student() {

super();

// TODO Auto-generated constructor stub

}

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;

}

Map接口概述:

将键映射到值的对象,一个映射不能包含重复的键,每个键最多只能映射到一个值。

Map接口和Collection接口的不同：

Map是双列的,Collection是单列的

Map的键唯一,Collection的子体系Set是唯一的

Map集合的数据结构只针对键有效，跟值无关

Collection集合的数据结构是针对元素有效

import java.util.HashMap;

import java.util.Map;

Map接口的常用功能以及简单用法：

添加功能：

V put(K key, V value)：将给定的键值对元素，存储到集合中。

如果当前的键，在集合中第一次存储，添加功能，把对应的键和值进行存储。

如果当前的键，在集合中已经存在，修改功能，把当前的键所对应的值进行更新为新的值。

删除功能：

void clear() 清空集合中所有的键值对元素。

V remove(Object key): 把给定的键，所对应的键值对元素，在集合中删除，返回被删除元素的值(指键值对元素中的值)。

判断功能：

boolean containsKey(Object key)：判断当前集合中是否包含指定的键。

boolean containsValue(Object value)：判断当前集合是否包含指定的值。

boolean isEmpty()：判断当前集合是否为空。

长度功能：

int size()：获取集合中键值对元素的个数。

案例：（需要运行时将对应的单行注释解开即可）

public class MapMethodDemo {

public static void main(String[] args) {

//创建集合对象

Map<String,String> map = new HashMap<String,String>();

//V put(K key, V value)

map.put("谢霆锋", "张柏芝");

map.put("李亚鹏", "王菲");

map.put("汪峰", "章子怡");

//String old = map.put("谢霆锋", "王菲");

//System.out.println("old:"+old);

//void clear() 清空集合中所有的键值对元素

//map.clear();

//V remove(Object key): 把给定的键，所对应的键值对元素，在集合中删除，返回被删除元素的值(指键值对元素中的值)

//String result = map.remove("汪峰");

//System.out.println(result);

//boolean containsKey(Object key)：判断当前集合中是否包含指定的键

//System.out.println( "containsKey:"+ map.containsKey("汪峰") );

//System.out.println( "containsKey:"+ map.containsKey("孙楠") );

//boolean containsValue(Object value)：判断当前集合是否包含指定的值

//System.out.println( "containsValue:"+ map.containsValue("王菲") );

//System.out.println( "containsValue:"+ map.containsValue("范冰冰") );

//boolean isEmpty()：判断当前集合是否为空

//System.out.println( "isEmpty:" + map.isEmpty() );

//int size()：获取集合中键值对元素的个数

System.out.println("size:" + map.size());

//显示

System.out.println(map);

获取功能：

Set<K> keySet(): 获得一个包含所有键的 Set集合

Collection<V> values(): 获得一个包含所有值的Collection集合

V get(Object key) : 根据指定的键，获取对应的值

public class MapMethodDemo2 {

public static void main(String[] args) {

//创建Map集合对象

Map<String,String> map = new HashMap<String, String>();

//添加元素

map.put("谢霆锋", "张柏芝");

map.put("李亚鹏", "王菲");

map.put("汪峰", "章子怡");

//Set<K> keySet(): 获得一个包含所有键的 Set集合

Set<String> keys = map.keySet();

System.out.println(keys);

//Collection<V> values(): 获得一个包含所有值的Collection集合

Collection<String> values = map.values();

System.out.println(values);

//V get(Object key) : 根据指定的键，获取对应的值

String value = map.get("汪峰");

System.out.println(value);

String value2 = map.get("刘德华");

System.out.println(value2);

}

Map集合的两种遍历方式:

1: 键找值

2: 通过键值对元素对象，找对应的键，找对应的值

第一种方式:

键找值通过指定的键，获取对应的值

a: 获取到Map集合中所有的键的Set集合

b: 遍历键的集合，得到每一个键

c: 通过当前的键，获取对应的值

public class MapDemo {

public static void main(String[] args) {

// 创建Map集合

Map<String, String> map = new HashMap<String, String>();

// 添加元素

map.put("谢霆锋", "张柏芝");

map.put("李亚鹏", "王菲");

map.put("汪峰", "章子怡");

// 遍历

// a: 获取到Map集合中所有的键的Set集合

Set<String> keys = map.keySet();

// b: 遍历键的集合，得到每一个键

for (String key : keys) {

// c: 通过当前的键，获取对应的值

String value = map.get(key);

// 显示

System.out.println(key + "--" + value);

}

第二种方式:

通过键值对元素对象，找对应的键，找对应的值结婚证方式

//a:获取所有键值对元素的Set集合

//b:遍历Set集合，得到每一个键值对元素对象

//c:通过键值对元素对象，获取键，获取值

方法：Set<Map.Entry<K,V>> entrySet()：获得一个包含多个键值对元素的Set集合

public class MapDemo2 {

public static void main(String[] args) {

//创建Map集合

Map<String,String> map = new HashMap<String,String>();

//添加元素

map.put("谢霆锋", "张柏芝");

map.put("李亚鹏", "王菲");

map.put("汪峰", "章子怡");

//遍历

//a:获取所有键值对元素的Set集合

Set<Map.Entry<String,String>> entrySet = map.entrySet();

//b:遍历Set集合，得到每一个键值对元素对象

for ( Map.Entry<String,String> entry : entrySet) {

//c:通过键值对元素对象，获取键，获取值

String key = entry.getKey();//获取键

String value = entry.getValue();//获取值

System.out.println(key +"--"+ value);

}

import java.util.HashMap;

import java.util.Map.Entry;

import java.util.Set;

HashMap类概述:

键是哈希表结构，可以保证键的唯一性

存储允许使用 null 值和 null 键

线程不同步-- 效率高-- 不安全

Map集合中的键要求保证唯一，那么，HashMap集合中，如何保证键的唯一呢？

重写 hashCode() 与 equals()方法。

注意：这里面的唯一指的是键唯一，针对键有效，与值无关。

使用HashMap存储字符串并遍历

键 String 值 String

案例一：

public class HashMapDemo {

public static void main(String[] args) {

//创建HashMap集合

HashMap<String,String> hm = new HashMap<String,String>();

//添加键值对元素到集合

hm.put("谢霆锋", "张柏芝");

hm.put("李亚鹏", "王菲");

hm.put("汪峰", "章子怡");

//遍历方式1 键找值

//a: 获取到Map集合中所有的键

Set<String> keys = hm.keySet();

//b: 获取到每一个键

for (String key : keys) {

//c: 通过键，找对应的值

String value = hm.get(key);

System.out.println(key+"---"+value);

}

//遍历方式2 键值对找键找值

//a: 获取所有的键值对元素对象

Set<Entry<String, String>> entrySet = hm.entrySet();

//b: 获取到每一个键值对元素对象

for (Entry<String, String> entry: entrySet) {

//c: 通过当前的键值对元素对象，获取键，获取值

String key = entry.getKey();// 获取键

String value = entry.getValue(); //获取值

System.out.println(key+"---"+value);

}

案例二：

HashMap集合键是Person值是String的案例

键是Person

值是String

注意了：如果HashMap集合中的键是自定义类对象，那么需要重写 hashCode() 与 equals()。

public class HashMapDemo3 {

public static void main(String[] args) {

//创建集合对象

HashMap<Person,String> map = new HashMap<Person,String>();

//添加元素

Person s1 = new Person("周瑜", 28);

Person s2 = new Person("小乔", 18);

Person s3 = new Person("大乔", 19);

map.put(s1, "itcast001");

map.put(s2, "itcast002");

map.put(s3, "itcast003");

map.put(s3, "itcast004");// 由于s3 键已存储用itcast004 替换itcast003

//遍历键值对找键找值

Set<Entry<Person, String>> entrySet = map.entrySet();

//获取到每一个键值对元素对象

for (Entry<Person, String> entry : entrySet) {

Person key = entry.getKey();

String value = entry.getValue();

System.out.println(value +"---"+ key.getName() +"---"+key.getAge() );

}

//键的自定义类person 需要重写 hashCode() 与 equals()。

package cn.itcast_03_HashMap;

public class Person {

private String name;

private int age;

public Person() {

super();

// TODO Auto-generated constructor stub

}

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;

}

//重写 hashCode()

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + age;

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

//重写 equals()。

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Person other = (Person) obj;

if (age != other.age)

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

LinkedHashMap类概述:

Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序.

* 底层：哈希表 + 链表

* 有序(元素的存与取顺序一致)

* 线程不同步 -- 效率高-- 不安全

public class LinkedHashMapDemo {

public static void main(String[] args) {

//创建集合对象

LinkedHashMap<String,String> map = new LinkedHashMap<String,String>();

//添加元素到集合

map.put("谢霆锋", "张柏芝");

map.put("李亚鹏", "王菲");

map.put("汪峰", "章子怡");

//遍历键找值

Set<String> keys = map.keySet();

for (String key : keys) {

//键找值

String value = map.get(key);

System.out.println(key +"---"+value);

}

TreeMap类概述:

键是红黑树结构，可以保证键的排序和唯一性.

案例:

TreeMap集合键是Student值是String的案例

键是Student

值是String

注意了，键是自定义类对象，较器接口进行排序

public class TreeMapDemo2 {

public static void main(String[] args) {

//创建TreeMap集合对象, 同时实现比较器

TreeMap<Student,String> map = new TreeMap<Student,String>(new Comparator<Student>() {

@Override

public int compare(Student s1, Student s2) {

//名字

int num = s1.getName().compareTo(s2.getName());

//年龄

int result = (num==0) ? (s1.getAge() - s2.getAge()) : num ;

return result;

}

});

//添加元素到集合

Student s1 = new Student("z周瑜", 28);

Student s2 = new Student("x小乔", 18);

Student s3 = new Student("d大乔", 19);

map.put(s1, "itcast001");

map.put(s2, "itcast002");

map.put(s3, "itcast003");

map.put(s1, "itcast110");

//遍历

Set<Student> keys = map.keySet();

//获取到每一个键

for (Student key : keys) {

//键找值

String value = map.get(key);

System.out.println(value +"---"+key.getName()+"---"+key.getAge() );

}

//键的自定义类

public class Student {

private String name;

private int age;

public Student() {

super();

// TODO Auto-generated constructor stub

}

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;

}

Collections类概述:

针对集合操作的工具类.

Collections成员方法

public static <T> void sort(List<T> list) 排序

public static <T> int binarySearch(List<?> list,T key) 二分查找

public static <T> T max(Collection<?> coll) 最大值

public static void reverse(List<?> list) 反转

public static void shuffle(List<?> list) 随机打乱

public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 替换

public class CollectionsDemo {

public static void main(String[] args) {

List<Integer> list = new ArrayList<Integer>();

list.add(12);

list.add(8);

list.add(11);

list.add(7);

list.add(23);

list.add(54);

list.add(22);

list.add(1);

list.add(79);

System.out.println(list);

System.out.println("排序后：");

Collections.sort(list);

System.out.println(list);//[1, 7, 8, 11, 12, 22, 23, 54, 79]

System.out.println("二分查找 12 索引:"+ Collections.binarySearch(list, 12));

System.out.println("最大值：" + Collections.max(list));

System.out.println("反转后");

Collections.reverse(list);

System.out.println(list);

System.out.println("随机打乱后");

Collections.shuffle(list);

System.out.println(list);

System.out.println("替换后:");

System.out.println(Collections.replaceAll(list, 11, 111));

System.out.println(list);

}

0 0