黑马程序员_【总结】_集合框架知识梳理1

集合框架知识梳理1

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

---------------------------------------------------------------------------------------------------------------------------------------------

 Collection集合框架

-------------------------------------------

1、集合用于储存对象、长度可变、可存储各种类型对象

2、集合中存储的都是对象的引用（地址）

--------------------------------------------

|--Collection  接口 单列集合

|-- List

|-- ArrayList

|-- LindedList

|-- Vector

|-- Set

|-- HeshSet

|-- TreeSet

--------------------------------------------

【0】

List： 可重复、有序。

Set: 不可重复、无序。

【1-1】

ArrayList

本质上，ArrayList是对象引用的一个可变长度数组。

底层： 数据结构。查询快，增删慢，线程不同步

Arrays.asList() 能直接返回一个非八大基本状态的数组。

【1-2】

LiknedList

底层： 链表结果。增删快，查询慢。  Vector升级版

Vector： 其特点就是 枚举 迭代的前身。

跟迭代是极其的相似：

Vector<String> v = new Vector<String>();
v.add("java01");
v.add("java01");
v.add("java01");

Enumeration<String> en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}

【1-3】

迭代器

Iterator

for(Iterator<T>it=al.iterator(); it.hasNext(); ){
System.out.println(it.next());
}

【2-1】

HeshSet

底层： 哈希值

通过 hashCode 方法保证唯一性，当哈希值地址相同时，
会调用equals 方法再次判断

【2-2】

TreeSet

底层： 二叉树，

1、进行操作实现 Comparable 接口 覆盖 compareTo()方法，当主要条件相同时，
比较次要元素，保证运算唯一性的语语句是：compareTo()方法 return 0;

2、当元素不具备比较性或不是需要的比较时，定义一个类实现 Comparator接口
重写 compare()方法。
TreeSet比较方式一
main方法：

public static void main(String[] args) {
// Comparable 内部排序【A】
TreeSet  ts=new TreeSet();
//Comparator 外部比较器 【B】
//TreeSet  ts=new TreeSet(new Myc());
ts.add(new Stu("lisi02",22));
ts.add(new Stu("lisi007",20));
ts.add(new Stu("lisi009",19));
ts.add(new Stu("lisi06",19));
ts.add(new Stu("lisi06",18));
ts.add(new Stu("lisi03",18));
Iterator it=ts.iterator();
while(it.hasNext()){
Stu s=(Stu)it.next();
System.out.println(s);
}
}

Comparable 内部实现比较方法：

class Stu implements Comparable{
String name;
int age;
Stu(String name,int age){
this.name = name;
this.age = age;
}
//覆盖该方法
public int compareTo(Object o) {
//1、-1、分别代表 正序、倒序
//return -1;
//也可以自定义--按照名字排序
if(!(o instanceof Stu)){
//如果不是该类型则抛出异常
throw new RuntimeException("，，，");
}
Stu s = (Stu)o;
//主条条件
int num = this.name.compareTo(s.name);
if(num==0){
//基本数据类型不能 compareTo 进行比较
num = new Integer(this.age).compareTo(new Integer(this.age));
}
return num;
}
public String toString(){
return name +"---"+age;
}
}

Comparator 外部 自定义比较器：

class Myc implements Comparator{
//覆盖
public int compare(Object o1, Object o2) {
Stu s1 = (Stu) o1;
Stu s2 = (Stu) o2;
//主条件
int num = s1.name.compareTo(s2.name);
if(num==0){
//次条件
num = new Integer(s1.age).compareTo(new Integer(s2.age));
}
return num;
}
}//<span style="white-space:pre">		</span>int num = s1.name.compareTo(s2.name); 
//<span style="white-space:pre">		</span>return num==0?new Integer(s1.age).compareTo(new Integer(s2.age)):num;   写法2

【3】对比 List  和 Set    集合。

class Person{
String name;
int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name+">>"+age;
}
}
public class CollectionTest{
public static void main(String [] args){
ArrayList<Person> al = new ArrayList<Person> ();
al.add(new Person("li01",19));
al.add(new Person("li01",19));
al.add(new Person("li02",20));

// 迭代器--方式一   不能add 、remove
for(Iterator<Person> it = al.iterator(); it.hasNext() ; ){
System.out.println(it.next());
}
System.out.println("---------------------");
//ListIterator  迭代时，可以  并发交互了。
for(ListIterator<Person>lit = al.listIterator(); lit.hasNext() ; ){
Person obj = lit.next();
if(obj.name.equals("li02")){
lit.add(new Person("li03",18));
lit.add(new Person("li03",32));
}
if(obj.name.equals("li01")){
lit.remove();
}
}
// 迭代器--方式二
Iterator<Person> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next()+"...方式二");
}
System.out.println("---------------------");
HashSet<String> hs = new HashSet<String>();
hs.add("ya01");
hs.add("ya01");
hs.add("ya02");
// 打印 HashSet  集合
for(String has : hs){
System.out.println(has+"...");
}
}
bd84
}

结论：

1、集合就是一个可变长度的数组

2、List 是可重复的

3、Set  是不可重复的

4、取出方式有1、迭代Iterator   ：for、while两种方式。
    2、高级for

5、ListIterator  可以在迭代时，进行并发交互

111：常见方法

 1、新增：add() 2、清除： clear()3、是否包含：contains(Object o)5、是否为空：isEmpty() 

 5：排序：toArray() 7、删除：remove(Object o) 

 8、全部删粗：removeAll(Collection<?> c) 9：长度、个数：size() 

等，具体更详细，要学会查看API

【4】

Generic

泛型的好处：
1、安全。
2、消除强制类型转换

泛型 就是指定一种类型。

其实泛型<>就是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

1、

泛型机制 

ArrayList<Person> al = new ArrayList<Person> (); 

迭代器对应：

Iterator<Person> it = al.iterator()

泛型类

泛型类定义的泛型，在整个类中有效

如果被方法使用，那么泛型的对象明确早操作的具体类型后

所有要操作的类型就已经固定了。

class Demo <T> {
public void show(T t){
System.out.println("show:"+t);
}
public void print(T t){
System.out.println("print:"+t);
}
}

泛型方法

为了让不同方法可以操作不同类型，而且类型还不确定

那么可以将泛型定义在方法上。
public void show(T t){    //随着泛型类的类型走 
System.out.println("show:"+t);
}
//public <T> void print(T t){    这里的t上上面的一样的吗，不是。
public <Q> void print(Q q){      //为了方便阅读，还是写成不一样的。
System.out.println("print:"+q);
}

泛型接口

接口接收位置类型

方法也接收位置类型

主函数 就可以传递任意类型的参数

interface Inter<T>{   //
void show(T t);
}
class InterImpl<T> implements Inter<T>{
public void show(T t){
System.out.print(t);
}
}
class InterDemo{
public static void main(String[] args) {
InterImpl<String> in = new InterImpl();
InterImpl<Integer> in2 = new InterImpl();
in.show("haha");
in2.show(123);
}
}

主函数 就可以传递任意类型的参数

静态泛型

特殊之处

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo3<T> {

//public static <T> void showS(T t){// 报错，不能和非静态类同类型
//public <T> static  void showS(T t){//报错，书写格式错误

public static <M> void showS(M m){// 静态泛型方法不可为非静态泛型类相同类型，原理很简单，静态先加载，
System.out.println("print:"+m);
}
}

【4-1】

泛型的高级引用

<?>  通配符，也可以理解为占位符。

泛型的限定：

<? enteds E>   E 可以接收 E类型或者E的子类型。上限。

<? super  E>   E 可以接收 E类型或者E的父类型。下限。

public class test2
{
public static void main(String[] args)
{
ArrayList<Personp> alp= new ArrayList<Personp> ();
alp.add(new Personp("wocao01"));
alp.add(new Personp("wocao02"));

ArrayList<Student> als= new ArrayList<Student> ();
als.add(new Student("002s"));
als.add(new Student("003s"));

ArrayList<Pupil> alx= new ArrayList<Pupil> ();
alx.add(new Pupil("xxx11"));
alx.add(new Pupil("dd333"));

show(als);
show(alp);
show(alx);
showX(als);
showX(alp);
//showX(alx);  //【P】
}
public static void show(ArrayList<? extends Personp> al){
for(Iterator<? extends Personp> it=al.iterator();it.hasNext(); ){
System.out.println(it.next().getName());
}
}
public static void showX(ArrayList<? super Student> al){
for(Iterator<? super Student> it=al.iterator();it.hasNext(); ){
//System.out.println(it.next().getName());//编译不通过
System.out.println(it.next());
}
}
}
class Personp{
private String name;
Personp(String name){
this.name=name;
}
public String getName(){
return name;
}
public String toString(){
return name+"";
}
}
class Student extends Personp{
Student(String name){
super(name);
}
}
class Pupil extends Student{
Pupil(String name){
super(name);
}
}

这个时候 【p】 处就出现了错误。

因为

<? extends Personp> 是 指 Personp  和Personp的子类    Student、Pupil 都是人的子类

<? super Student> 是指Student   和Student 的父类 Pupil是 Student 的子类，所以报错。

再看下面的代码： 继承关系依然用上面的代码。

充分的利用了泛型的限定， TreeSet进行了排序，并简洁了很多代码。

public class test2 {
public static void main(String[] args) {
TreeSet<Personp> tp = new TreeSet<Personp>(new Comp());
tp.add(new Per("fds08"));
tp.add(new Per("asd07"));
tp.add(new Per("asd01"));
TreeSet<Student> ts = new TreeSet<Student>(new Comp());
ts.add(new Stu("fds----08"));
ts.add(new Stu("asd---07"));
ts.add(new Stu("asd---01"));
TreeSet<Pupil> tx = new TreeSet<Pupil>(new Comp());
tx.add(new Pul("fds>>>08"));
tx.add(new Pul("asd>>>07"));
tx.add(new Pul("asd>>>01"));
show(tx);
show(ts);
show(tp);
}
//通过泛型向下限定， 指定了类型的范围。
public static void show(TreeSet<? extends Personp> ts){
for(Iterator<? extends Personp> it = ts.iterator(); it.hasNext(); ){
System.out.println(it.next().getName());
}
}
}
//不用在依次设定比较器，泛型设定为父类， 让比较器通用了。
class Comp implements Comparator<Personp>{
public int compare(Personp p1,Personp p2){
return p1.getName().compareTo(p2.getName());
}
}

通过对 比较器的 泛型限定，父类， 使其具备了通用性，但是局限于父类以及父类子类。

---------------------------------------------------------------------------------------------------------------------------------------------

----------
android培训、 java培训、期待与您交流！----------
黑马官网