-------
1、为什么出现集合类？
面向对象对事物的体现都是以对象的形式，为了方便对多个对象的操作，就对对象进行存储。
集合就是存储对象最常用的一种方式.
2、数组和集合都是容器，两者有何不同？
数组长度固定，而集合长度是可变的
数组值可以存储对象，还可以存储基本数据类型;而集合只能存储对象
数组存储数据类型是固定的，而集合存储的数据类型不固定
3、集合类的特点：
集合只能存储对象
集合的长度是可变的
集合可以存储不同类型的对象
4、常用集合类之间的层次、继承关系
Collection
|--List：元素是有序的，元素可以重复。因为飞机和体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度快，但是增删稍慢。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组结构，线程同步，被ArrayList替代了，因为效率低。
|--Set：元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表HashSet通过hashCode和equals判断元素是否重复。如果元素的hashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。对于判断元素是否存在，以及删除等操作依赖的方法是元素的hashCode和equals方法。
|--TreeSet：可以对Set集合中的元素进行排序，底层数据结构是二叉树。它保证元素唯一性的依据是compareTo方法的return。TreeSet允许自定义排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需的，这是就需要让集合自身具备比较性，在集合初始化时就让其具有比较性方式。
|--Map：用于保存具有映射关系的数据。
|--HashTable：底层是哈希表数据结构允许使用null键和null值；线程不同步，效率高；保证元素唯一性的:原理：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true
|--HashMap：底层数据结构是哈希表。HashMap通过hashCode和equals判断元素是否重复。如果元素的hashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
|--TreeMap：可以对Map集合中的元素进行排序，底层数据结构是二叉树。它保证唯一性的依据是compareTo方法的return。TreeSet允许自定义排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需的，这是就需要让集合自身具备比较性，在集合初始化时就让其具有比较性。
List:
特有方法，凡是可以操作角标的方法都是该体系特有的方法
增
add(intindex,Eelement);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(form,to);
listIterator();
List集合特有的迭代器:ListIterator是Iterator的子接口在迭代时，不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException并发操作异常.所以在迭代时，只能用迭代器的方法操作元素，可以Iterator方法是有限的只能对元素进行判断，取出和删除的操作如果想要其他的操作如添加，修改等，就需要使用其子接口ListIterator该接口只能通过List集合listIterator方法获取.
import java.util.*;
/*
1.add方法的参数类型是Object，以便于接受任意类型对象
2.方法中存储的都是对象的引用或者地址
什么是迭代器呢？
其实就是集合的取出元素的方式
*/
class CollectionDemo {
public static void main(String[] args) {
// method_2();
// base_method();
get_method();
}
public static void sop(Object obj) {
System.out.println(obj);
}
public static void base_method() {
// 创建一个集合容器，使用Collection接口的子类：ArrayList
ArrayList al = new ArrayList();
// 1,添加元素
al.add("java01");// add()参数类型是Object类型的，因为可以是任意对象
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合：" + al);
// 2.获取个数，集合长度size();
sop("size=" + al.size());
// 3.删除元素
al.remove("java02");
sop("改变后的集合：" + al);
al.clear();// 清空集合
sop(al);
// 4.判断集合是否为空
sop("判断元素是否存在" + al.contains("java01"));
sop("判断集合是否为空" + al.isEmpty());
}
public static void method_2() {
ArrayList al1 = new ArrayList();
al1.add("java01");// add()参数类型是Object类型的，因为可以是任意对象
al1.add("java02");
al1.add("java03");
ArrayList al2 = new ArrayList();
al2.add("java05");// add()参数类型是Object类型的，因为可以是任意对象
al2.add("java06");
al2.add("java04");
al2.retainAll(al1);// 取交集，al1中只会保留和al2中相同的元素
sop("al1:" + al1);
sop("al2:" + al2);
}
public static void get_method() {
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
/*
* Iterator it = al.iterator();//返回的是Iterator接口类型的对象，Iterator是一个集合的内部类
* while (it.hasNext()) { sop(it.next()); }
*/
for (Iterator it = al.iterator(); it.hasNext();)// 这样写不用在迭代结束后还保留it对象，因为it是for循环的一个内部变量，便于内存管理
{
sop(it.next());
}
}
}
import java.util.*;
class ListDemo {
public static void main(String[] args) {
// method();
// 演示列表迭代器
ArrayList al = new ArrayList();
// 添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合是：" + al);
ListIterator li = al.listIterator();
while (li.hasNext()) {
Object obj = li.next();
if (obj.equals("java02"))
li.set("java006");
if (obj.equals("java03"))
li.add("new");
sop("obj=" + obj);
}
sop(li.hasNext());
sop(li.hasPrevious());
sop("改变后的集合：" + al);
// 在迭代过程中，准备添加或者删除元素
/*
* Iterator it = al.iterator(); while (it.hasNext()) { Object obj =
* it.next(); if (obj.equals("java02"))
* //al.add("java008");//这步操作可能会引起并发访问异常，因为al有两种操作方式，容易产生安全隐患
* it.remove();
* sop("obj="+obj);//迭代过程中即使删除的元素也会被obj引用，所以也能打印出来，而且Iterator只有三个方法，有局限性
* }
*/
}
public static void method() {
ArrayList al = new ArrayList();
// 添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合是：" + al);
// 在指定位置添加元素
al.add(1, "java09");
// 删除指定位置的元素
// all.remove(2);
// 修改元素
al.set(2, "java007");
// 通过角标获取元素
// sop("get(1):"+al.get(1));
// sop(al);
// 获取所有元素
for (int x = 0; x < al.size(); x++) {
sop("al(" + x + ")=" + al.get(x));
}
Iterator it = al.iterator();
while (it.hasNext()) {
sop(it.next());
}
// 通过indexOf获取对象的位置
sop("index=" + al.indexOf("java09"));
List sub = al.subList(1, 4);
sop("sub=" + sub);
}
public static void sop(Object obj) {
System.out.println(obj);
}
}import java.util.*;
class ListDemo {
public static void main(String[] args) {
// method();
// 演示列表迭代器
ArrayList al = new ArrayList();
// 添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合是：" + al);
ListIterator li = al.listIterator();
while (li.hasNext()) {
Object obj = li.next();
if (obj.equals("java02"))
li.set("java006");
if (obj.equals("java03"))
li.add("new");
sop("obj=" + obj);
}
sop(li.hasNext());
sop(li.hasPrevious());
sop("改变后的集合：" + al);
// 在迭代过程中，准备添加或者删除元素
/*
* Iterator it = al.iterator(); while (it.hasNext()) { Object obj =
* it.next(); if (obj.equals("java02"))
* //al.add("java008");//这步操作可能会引起并发访问异常，因为al有两种操作方式，容易产生安全隐患
* it.remove();
* sop("obj="+obj);//迭代过程中即使删除的元素也会被obj引用，所以也能打印出来，而且Iterator只有三个方法，有局限性
* }
*/
}
public static void method() {
ArrayList al = new ArrayList();
// 添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add(4);
sop("原集合是：" + al);
// 在指定位置添加元素
al.add(1, "java09");
// 删除指定位置的元素
// all.remove(2);
// 修改元素
al.set(2, "java007");
// 通过角标获取元素
// sop("get(1):"+al.get(1));
// sop(al);
// 获取所有元素
for (int x = 0; x < al.size(); x++) {
sop("al(" + x + ")=" + al.get(x));
}
Iterator it = al.iterator();
while (it.hasNext()) {
sop(it.next());
}
// 通过indexOf获取对象的位置
sop("index=" + al.indexOf("java09"));
List sub = al.subList(1, 4);
sop("sub=" + sub);
}
public static void sop(Object obj) {
System.out.println(obj);
}
}Set:无序，不可以重复元素
--HashSet：数据结构是哈希表，线程是非同步的
保证元素唯一性的原理，判断元素的hashCode值是否相同
如果相同，还会继续判断元素的equals方法，是否为true
--TreeSet：可以对Set集合中的元素进行排序
底层数据结构是二叉树
1，保证元素唯一性的依据compareTo方法return()。
2，当元素不具备比较性时，或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性
在集合初始化时，就有了比较方式
需求；
往TreeSet集合中存储自定义对象学生
想按照学生的年龄进行排序
记住：排序时，当主要条件相同时，一定判断次要条件
import java.util.*;
class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02", 22));
ts.add(new Student("lisi007", 20));
ts.add(new Student("lisi09", 19));
ts.add(new Student("lisi08", 19));
Iterator it = ts.iterator();
while (it.hasNext()) {
Student stu = (Student) it.next();
System.out.println(stu.getName() + "::" + stu.getAge());
}
}
}
class Student implements Comparable// 该接口强制让学生具备比较性
{
private String name;
private int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public int compareTo(Object obj) {
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student) obj;
System.out.println(this.name + "::compare to::" + s.name);
if (this.age > s.age)
return 1;
if (this.age == s.age) {
return this.name.compareTo(s.name);
}
return -1;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}Map集合：
1.添加
put(Kkey,Vvalue)
putAll(Map<?extendsK,?extendsV>m)
2.删除
clear()
remove(Objectkey)
3.判断
containsKey(Objectvalue)
containsValue(Objectvalue)
isEmpty()
4.获取
size()
values()
get(Objectkey)
keySet()
entrySet()
Hashtable:底层是哈希表数据结构，不可以存入null键null值,该集合是线程同步的
HashMap:底层是哈希表数据结构允许使用null值和null键该集合是不同步的
TreeMap:底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序
map集合的两种取出方式:
第一种：Set<K> keySet()
返回此映射中包含的键的Set视图，将Map集合中所有的键存入Set集合，然后再通过Set集合的
迭代器取出所有的键，再根据get方法获取每个键的值；
第二种：Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的Set视图，将Map集合中的映射关系存入到Set集合中，
这个映射关系的数据类型是Map.entry,再通过Map.Entry类的方法再要取出关系里面的键和值
第一种：import java.util.*;
public class MapDemo2 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("02", "zhangshan02");
map.put("03", "zhangshan03");
map.put("01", "zhangshan01");
map.put("04", "zhangshan04");
// 先获取map集合的所有键的Set集合，keySet();
Set<String> keySet = map.keySet();
// 有了Set集合，就可以获取其迭代器
Iterator<String> it = keySet.iterator();
while (it.hasNext()) {
String key = it.next();
// 有了键可以通过map集合的get方法获取其对应的值
String value = map.get(key);
System.out.println("key--" + key + ",value" + value);
}
}
}第二种：
import java.util.*;
public class MapDemo2 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("02", "zhangshan02");
map.put("03", "zhangshan03");
map.put("01", "zhangshan01");
map.put("04", "zhangshan04");
Set entrySet = map.entrySet();
Iterator it = entrySet.iterator();
while(it.hasNext()) {
Map.Entry me = (Map.Entry)it.next();
System.out.println(me.getKey()+"::::"+me.getValue());
}
<span style="white-space:pre"> </span>}
}Collection和Collections关系：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。
集合框架中的工具类
Collections
对集合进行查找
取出集合中的最大值，最小值
对List集合进行排序
……
Arrays
将数组转成List集合
对数组进行排序
489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
