java基础14（Javaoo9）——集合框架-CSDN博客

本文链接：https://blog.csdn.net/WB1224678/article/details/53574415

java基础14（Javaoo9）——Java集合框架（Java Collection Framework）

(简称JCF)

1.什么是框架？

—— 为了解决某一问题而预先设计的具有继承关系的类与接口，在使用过程中，只需从中选择相应的就可以实现功能.

集合框架包括三大内容：对外接口、接口的实现、对集合运算的方法

2.集合分类：List（列表）、Set（集）、Map（映射）

—— 了解各自的特点，分清楚什么时候用？

Collection是集合框架的根接口（核心接口）

Collection直接衍生List、Set接口，间接衍生Map接口

语法：

1.集合的基本操作：放，取，删，改，遍历

2.新知识点：①泛型 ②迭代器 ③hadhcode()

3.集合工具类:比较器

1.List(列表)：

public class TestList {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

* List--列表。特点：线性--有序---外部放入的顺序即为列表存的顺序，所以有下标

* 最常用子类---ArrayList、LinkedList

//首先产生集合类的对象

//ArrayList---底层实现就是使用的数组，它完成对数组的封装

//LinkedList--底层实现采用双向链表的结构

* ArrayList与LinkedList的使用场景

* 1、当需要大量做查询某个元素的时候，ArrayList效率高于LinkedList

* 2、往尾部添加或删除元素，ArrayList效率高于LinkedList

* 3、往中间添加或删除元素，LinkedList效率高于ArrayList

* 面试时常常用ArrayList与Vector做辨析

* 因为：Vector同样是List分支下面的集合类，底层使用的数据结构仍然是数组，提供的方法也是同样的API

* 差异：1、ArrayList是线程不安全的，效率高的

* 2、Vector是线程安全的，效率低的

* 使用场景：Vector在多线程情况下，且可能出现线程安全性问题时，才会用来替代ArrayList

// ArrayList lst = new ArrayList();

LinkedList lst = new LinkedList();

//<类型>---泛型---表示该集合只能存放该类型及其子类的元素

LinkedList<Student> stuLst = new LinkedList<Student>();

//使用集合类对象

//1、放入元素

lst.add("hello");

lst.add(new Date());

lst.add(new Student("zhang3",25,78));

lst.add(10);//自动封箱

stuLst.add(new Student("Li4",18,88));

//2、得到元素个数

System.out.println(lst.size());

//3、可以根据位置获取某个元素

System.out.println(lst.get(1));

Student stu = stuLst.get(0);

//4、可以修改某个位置的元素

lst.set(3, 250);

System.out.println(lst.get(3));

System.out.println(lst.contains(250));

//5、删除某个位置的元素

lst.remove(3);

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

//6、对List进行遍历

//6-1、普通for循环

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

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

}

//6-2、for-each循环---JDK1.5之后使用

for(Object obj : lst){

System.out.println(obj);

}

//6-3、集合框架类专用遍历方式---迭代器--Iterator--JDK1.5之前使用

Iterator it = lst.iterator();//获得迭代器对象

while(it.hasNext()){

Object obj = it.next();

System.out.println(obj);

}

2.Set（集）：

public class TestSet {

public static void main(String[] args) {

* Set--集。特点：不能存放重复元素，无序---外部放入的顺序不是内部存放的顺序，所以没有下标

* 最常用子类---HashSet

//首先产生集合对象

// HashSet set = new HashSet();

// HashSet<Student> stuSet = new HashSet<Student>();

//使用集合类对象

//1、放入元素

// set.add("hello");

// set.add(new Date());

// set.add(new Student("zhang3",25,78));

// set.add(10);//自动封箱

// set.add("hello");

// stuSet.add(new Student());

//2、得到元素个数

// System.out.println(set.size());

//3、不可以根据位置获取某个元素（没有下标）

//4、不可以修改某个位置的元素(没有下标)

//5、不可以删除某个位置的元素(没有下标)

//6、可以根据传入的对象，删除Set集合中的重复对象

// set.remove(new Student("zhang3",25,78));

// System.out.println(set.size());

//7、获取Set集合中的元素，只能使用遍历的方式

//7-1、for-each循环

// for(Object obj : set){

// System.out.println(obj);

// }

//7-2、集合框架类专用遍历方式---迭代器--Iterator--JDK1.5之前使用

// Iterator it = set.iterator();

// while(it.hasNext()){

// Object obj = it.next();

// System.out.println(obj);

// }

* 探究---HashSet是如何判断两个对象是重复对象的

* 1、两个对象的equals判断必须返回true

* 2、两个对象的Hash值必须相等

HashSet set = new HashSet();

Student stu1 = new Student("zhang3",18,90);

Student stu2 = new Student("zhang3",18,90);

set.add(new Date());

set.add(stu1);

set.add(stu2);

System.out.println(set.size());

System.out.println(stu1.equals(stu2));

}

3.Map（映射）

public class TestMap {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

* Map--映射。特点：用键值对的方式保存数据。---数据在Map集合中是成对存放的

* ---每个元素除了有值，还有一个唯一的键需要我们定义

* 最常用子类---HashMap、Properties

//首先产生集合对象

HashMap map = new HashMap();

HashMap<String,Student> stuMap = new HashMap<String, Student>();

//使用集合类对象

//1、放入元素

map.put(1, "hello");

map.put("world", 5);

map.put("1", "helloworld");

stuMap.put("001", new Student("zhang3",18,76));

//2、得到元素个数

System.out.println(map.size());

//3、取数据--要根据键获取值

System.out.println(map.get("2"));

Student stu = stuMap.get("001");

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

//4、修改元素--仍然调用put方法，只需要放入相同的键

map.put(1,new Date());

//5、删除元素--调用remove方法，根据键进行删除

map.remove("1");

* 在获取元素、删除元素的时候如果传入的键在map中不存在，不会报错！---危险

* 在修改元素的时候，如果传入的键在map中不存在，就直接变成增加新元素！---危险

* 解决方案：

* 利用containsKey方法，可以判断一个map集合中是否包含某个键

* 也有containersValue方法，判断一个map集合中是否包含某个值

* 判断的标准和Set中判断重复对象的方式一样，equals方法和hashCode方法

//6、对Map进行遍历

* 1、Map不能直接遍历---因为Map里的每一条记录都是一对儿，我们无法用一个变量来装

* 2、Map只能单独遍历所有的键或所有的值

* 3、统一使用for-each循环进行遍历

Set keySet = map.keySet();//把map中所有的键取出来放到一个Set集合中

Set<String> stuKeySet = stuMap.keySet();

Collection values = map.values();//把map中所有的值取出来放到一个Collection集合中

Collection<Student> stuValues = stuMap.values();

}

3.Collections工具类

public class TestCollecitons {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

* 常见的max（）、min（）取一个集合中的最大值和最小值--自己练习

//跟排序有关的方法--只能操作List集合

List<Student> lst = new ArrayList<Student>();

lst.add(new Student("zhang3",18,78));

lst.add(new Student("li4",28,87));

lst.add(new Student("wang5",22,76));

lst.add(new Student("zhao6",24,78));

lst.add(new Student("chen7",18,90));

//自然排序--Collections.sort()

Collections.sort(lst);

//反转--Collections.reverse()

// Collections.reverse(lst);

// 混排（随机排放）--Collections.shuffle()--洗牌效果

// Collections.shuffle(lst);

//显示结果

for(String in : lst){

System.out.println(in);

}