一、集合概念与框架结构
存储一个班学生信息，假定一个班容纳20名学生，使用数组的方式就可以，长度固定并且遍历速度快，可以存储基本类型和引用类型，如果班级人数增加了的话，用数组就很方便，在不知道程序运行时会需要多少个对象或者需要更复杂方式存储对象，可以使用Java集合框架。
集合的概念
1、集合:Java API所提供的一系列类的实例，可以用于动态存放多个对象。
2、Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中
3、特定：长度不固定，只能存储引用类型对象
Java集合框架
Collections：提供了对集合进行排序、遍历等多种算法实现
List接口存储一组不唯一（可重复），有序（插入有序）的对象
Set接口存储一组唯一（不可重复）的对象
Map接口存储一组键值对象，提供key到value的映射
Collection接口
1、Collection接口中定义了一些集合常用的方法
2、存储特点
Collection接口 - 定义了存取对象的方法。两个常用的子接口：
List接口：存放的元素有序且允许有重复的集合接口。
Set接口：存放的元素不包含重复元素的集合接口。
二、List集合及其实现类
1、List接口是Collection接口的子接口
2、实现List接口的集合类中的元素是有序的，且允许重复。
3、List集合中的元素都对应一个整数型的序号记载其在集合中的位置，可以根据序号存取集合中的元素。
4、JDK API所提供的List集合类常用的有：
ArrayList和LinkedList
List接口的常用方法
1、List接口比Collection接口中新增的几个实用方法：
（1）public Object get(int index);
返回列表中的元素数
（2）public Object add(int index,Object element);
在列表的指定位插入语指定元素，将当前处于该位置的元素（如果存在）和所有后继元素向右移动
（3）public Object set(int index,Object element);
用指定元素替换列表中指定位置的元素
（4）public Object remove(int index);
移除列表中指定位置的元素
（5）public ListIterator listIterator()
返回列表元素的列表迭代器
Collections实例：
package collections;
import java.util.*;
public class CollectionsDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
Collections.addAll(list,"Apple","Banana","Grape","Orange","Peach","Grape");
showList(list);
Collections.shuffle(list);//打乱List集合中的元素
System.out.println("打乱之后：");
showList(list);
Collections.reverse(list);//反转List集合
System.out.println("反转之后：");
showList(list);
}
public static void showList(List<String> list) {
for (String str : list) {
System.out.print(str + " ");
}
System.out.println();
}
}运行结果：
Apple Banana Grape Orange Peach Grape
打乱之后：
Apple Orange Peach Grape Banana Grape
反转之后：
Grape Banana Grape Peach Orange Apple
实现类 ---- ArrayList
1、ArrayList是使用数组结构实现的List集合。
2、优点：
对于使用索引取出元素有较好的的效率，使用索引来快速定位对象
缺点：
元素做删除或插入速度较慢，因为使用数组，需要移动后面的元素以调整索引顺序
实例：
package list;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("apple");
list.add("peach");
list.add("grape");
list.add("apple");//List可以添加重复元素
list.add("apple");
for(int i = 0; i < list.size();i++) {
//get(int index)方法是List接口扩展的方法
System.out.print(list.get(i) + " ");
}
System.out.println();
System.out.println("***********增强的for循环遍历***********");
for(String str : list) {
System.out.print(str + " ");
}
System.out.println();
System.out.println("包含apple吗？" + list.contains("apple"));
System.out.println("删除之前的元素个数：" + list.size());
list.remove("apple");
System.out.println("删除之后的元素个数：" + list.size());
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
}
}运行结果：
apple peach grape apple apple
***********增强的for循环遍历***********
apple peach grape apple apple
包含apple吗？true
删除之前的元素个数：5
删除之后的元素个数：4
peach grape apple apple
实现类 ---- LinkedList
1、LinkedList是使用了双向链表实现的集合
2、LinkedList新增了一些插入、删除的方法
3、优点：
对频繁的插入或删除元素有较好的的效率
缺点：
查询元素时，效率低，因为要从第一个元素查找
ArrayList和LinkedList分别在何时使用？
ArrayList遍历元素和随机访问元素的效率较高、插入和删除等操作频繁时性能低下，在这种情况下使用
LinkedLIst插入、删除元素效率较高，查找、遍历效率较低，在这种情况下使用
实例：
package list;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
System.out.println("模拟栈数据结构（先进后出FILO）：");
LinkedList<String> list = new LinkedList<String>();
list.push("A");
list.push("B");
list.push("C");
System.out.println(list.pop());
System.out.println(list.pop());
System.out.println(list.pop());
System.out.println("模拟队列数据结构（先进先出FIFO）：");
list.add("Bee");
list.add("Cat");
list.add("Dog");
System.out.println(list.removeFirst());
System.out.println(list.removeFirst());
System.out.println(list.removeFirst());
}
}运行结果：
模拟栈数据结构（先进后出FILO）：
C
B
A
模拟队列数据结构（先进先出FIFO）：
Bee
Cat
Dog
三、迭代器的使用
1、Iterator是专门的迭代输出接口。所谓的迭代输出就是将元素进行判断，判断是否有内容，如果有内容就把内容取出。
2、Iterator对象称作迭代器，用以方便的实现对集合内元素的遍历操作
3、所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了Iterator接口的对象。
Iterator it = coll.iterator();
while(it.hasNext()){
it.next();
}迭代器的使用方法
Iterator接口中定义了如下方法：
boolean hasNext();//判断游标右边是否有元素
Object next();//返回游标右边的元素并将游标移动到下一个位置
另一种遍历集合的方法：
1、用增强的for循环遍历集合中的元素
2、凡是能用Iterator迭代的集合都可以用JDK5.0中增强的for循环来简单的遍历
List<String> list = new ArrayList<String>();
...
for(String data : list){
System.out.print(data + " ");
}实例：
package iterator;
import java.util.*;
public class IteratorDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list,"China","America","Japan","China","England");
Iterator<String> iter = list.iterator();//返回List集合的迭代器
//通过迭代器遍历集合
while(iter.hasNext()) {
System.out.print(iter.next() + " ");
}
}
}运行结果：
China America Japan China England
泛型补充
泛型（Generic type）是对Java语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
泛型的好处：
解决了类型安全的问题（运行期出现"java.lang.ClassCastException"异常）
泛型类
class Gen<T>{
private T ob;//定义 泛型成员变量
public Gen(T ob){
this.ob = ob;
}
public T getOb(){
return ob;
}
public void setOb(T ob){
this.ob = ob;
}
public void showType(){
System.out.println("T的实际类型是：" + ob.getClass().getName());
}
}受限泛型
1、设置上限
类名称<? extends 上限类>
只能接收上限类对象或其子类对象
2、设置下限
类名称<? super 下限类>
接收下限类对象或其父类对象
注意：若定义泛型，可以将?设置为泛型标识。
实例：受限泛型 - 下限
package generic;
import java.util.*;
public class GenericDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("pen");
list.add("pencil");
list.add("pencilcase");
for (String str : list) {
System.out.print(str + " ");
}
method(list);
method(new ArrayList<Object>());
}
public static void method(List<? super String> list) {
List<String> temp = (List<String>)list;
temp.add("abc");
}
}运行结果：
pen pencil pencilcase
四、Set接口的实现类
1、Set接口没有提供Collection接口的额外方法，但实现Set接口的集合类中的元素是不可重复的。
2、JDK API中所提供的Set集合类常用的有：
HashSet：散列存放
TreeSet：有序存放
LinkedHashSet
HashSet存储原理
1、根据每个对象的哈希码值（调用hashCode()获得）用固定的算法算出它的存储索引，把对象存放在一个叫散列表的相应位置（表元）中：
（1）如果对应的位置没有其他元素，就只需要直接存入
（2）如果该位置有元素，会将新对象跟该位置的所有对象进行比较（调用equals()），以查看是否已经存在了：若还不存在就存放，已经存在就不存储。就比如说给村民安置住房，有一个前提：姓名不能相同，最开始安置是整村一起安置，最后又来了一户人家户主叫张三，相关人员就会根据姓名（对应于哈希码值）在已经统计好了的数据中查找，如果安置的所有 对象里没有张三这一家，就将他们安置，如果有，然后就查看他们的身份证，如果相同就不用安置了，如果不同则就不给他们在这一块安置，给他们另选。
HashSet集合的特点及使用技巧
1、HashSet不保存元素的加入顺序
2、HashSet接口存、取、删对象都有很高的效率
3、对于要存放到HashSet集合中的对象，对应的类可以重写hashCode(Object obj)方法和equals()以实现对象等规则的编写。
实例1：
package set.hashset;
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
set.add("京");
set.add("晋");
set.add("沪");
set.add("秦");
set.add("蜀");
for (String pro : set) {
System.out.print(pro +" ");
}
}
}运行结果：
蜀 秦 沪 晋 京
实例2：
package set.hashset;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return this.age * 2 - 10;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (obj == this) {
return true;
}
if (!(obj instanceof Person)) {
return false;
}
Person per = (Person) obj;
if (this.name != null && this.name.equals(per.name) && this.age == per.age) {
return true;
}
return false;
}
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 + "]";
}
}
package set.hashset;
import java.util.HashSet;
public class PersonHashSet {
public static void main(String[] args) {
HashSet<Person> set = new HashSet<Person>();
set.add(new Person("张三",18));
set.add(new Person("李四",19));
set.add(new Person("王五",20));
set.add(new Person("张三",18));
set.add(new Person("张三",18));
for (Person per : set) {
System.out.println(per);
}
}
}运行结果：
Person [name=张三, age=18]
Person [name=李四, age=19]
Person [name=王五, age=20]
TreeSet集合的特点：
TreeSet：可以对加入其中的元素进行排序。但前提是，必须制定排序规则。
构造方法：public TreeSet()
如果使用TreeSet的无参构造实例化TreeSet集合，则加入到TreeSet集合中的元素所对应的类必须实现java.lang.Compareble<T>接口，重写其中的int compareTo(T o)方法，并在方法中编写排序规则。
在Compareble<T>接口的compareTo(T o)方法中，指定排序规则（以升序为例）：
public int compareTo(Girl girl){
if(this.xxx > girl.xxx){
return 1;
}else if(this.xxx < girl.xxx){
return -1;
}else{
return 0;
}
}实例1：
package set.treeset;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<String> set = new TreeSet<String>();
set.add("A");
set.add("B");
set.add("C");
set.add("D");
set.add("B");
set.add("A");
set.add("S");
for (String c : set) {
System.out.print(c + " ");
}
}
}运行结果：
A B C D S
实例2：女孩排名
package set.treeset;
public class Girl implements Comparable<Girl> {
private String name;
private int face;
private double money;
public Girl() {
}
public Girl(String name, int face, double money) {
super();
this.name = name;
this.face = face;
this.money = money;
}
// 在该方法中指定排序规则
@Override
public int compareTo(Girl girl) {
if (girl == null) {
return 1;
}
if (this.face > girl.face) {
return -1;
} else if (this.face < girl.face) {
return 1;
} else {
if (this.money > girl.money) {
return -1;
} else if (this.money < girl.money) {
return 1;
} else {
return this.name.compareTo(girl.name);
}
}
}
@Override
public String toString() {
return "Girl [name=" + name + ", face=" + face + ", money=" + money + "]";
}
}
package set.treeset;
import java.util.TreeSet;
public class PersonTreeSet {
public static void main(String[] args) {
TreeSet<Girl> set = new TreeSet<Girl>();
set.add(new Girl("小红",80,20.5));
set.add(new Girl("小黄",60,80.9));
set.add(new Girl("小兰",95,2.5));
set.add(new Girl("小青",80,30.5));
set.add(new Girl("玉华",80,30.5));
set.add(new Girl("小紫",85,20));
for (Girl girl : set) {
System.out.println(girl);
}
}
}Girl [name=小兰, face=95, money=2.5]
Girl [name=小紫, face=85, money=20.0]
Girl [name=小青, face=80, money=30.5]
Girl [name=玉华, face=80, money=30.5]
Girl [name=小红, face=80, money=20.5]
Girl [name=小黄, face=60, money=80.9]
40万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
