黑马程序员-集合框架Collection的若干知识点

最新推荐文章于 2020-11-12 13:16:06 发布

jiayanxing1989

最新推荐文章于 2020-11-12 13:16:06 发布

阅读量523

点赞数

分类专栏： java 文章标签：集合框架

本文链接：https://blog.csdn.net/u013159249/article/details/22328429

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

概述：

所有集合类都位于java.util包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。

当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型。

Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些接口或实现类。Set和List接口是Collection接口派生的两个子接口，Queue是Java提供的队列实现，类似于List。

List：元素是有序的，元素可以重复，因为该集合体系有索引
ArrayList：底层的数据结构使用的是数组结构，查询速度很快，但是增删稍慢，线程不同步，默认10个元素
LinkedList：底层使用的链表数据结构，查询很慢，增删速度很快
Vector：底层是数组数据结构，和ArrayList一样，查询，增删，都很慢，Vector是1.0出现，ArrayList是1.2出现，线程同步，现在不用了。
Set：元素是无序的，元素不可以重复
HashSet
TreeSet
对于Set、List集合，最常用的实现类分别是HashSet、ArrayList这两个实现类。

下面重点介绍些关于list和set的重要知识点。

一迭代器

其实就是集合的取出元素的方式
就把取出方式定义在集合的内部，这样取出方式就可以直接访问结合内容的元素。那么取出方式就定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共共性内容：判断，取出。那么可以将写共性取出。
那么这些内部类都符合一个规则。该规则是Iterator。如何获取集合的取出对象呢？通过一个对外提供的方法：iterator);

ListIterator

1、list集合特有的迭代器，ListIterator是Iterator的子接口。
2、在迭代时候，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrenModificationException异常。
3、所以在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作
4、如果想要其他的操作，如添加、修改等，就需要使用其子接口，ListIterator。
5、该接口只能通过List集合的listIterator方法获取
6、hasPrevious()，前面是否有元素

代码示例如下：

import java.util.*;

class Demo{

public static void main(String[] args){

method_get();

}

public static void method_get(){

ArrayList al = new ArrayList();

al.add("java01");

al.add("java02");

al.add("java03");

al.add("java04");

sop("原集合是："+al);

al.add(1,"java09");

sop("后："+al);

//删除

al.remove(2);

//修改元素

al.set(2,"java07");

//通过角标获取元素

sop(al.get(1));

//获取所有元素

for(int x=0;x<al.size();x++){

sop("al("+x+") = "+al.get(x));

}

for(Iterator it = al.iterator();it.hasNext();){

sop(it.next());

}

//通过 indexOf获取对象的位置

sop(al.indexOf("java04"));

sop(al);

sop(al.subList(1,3));

ListIterator li = al.listIterator();

}

public static void sop(Object obj){

System.out.println(obj);

}

二：List集合共性方法

List：特有方法，凡是可以操作角标的方法都是该体系特有的方法
(1)、增：
add(index,element)
(2)、删：
remove(index)
(3)、改：
set(index,element)
(4)、查：
get(index)
subList()
listIterator()

三：Vector中的枚举)
1、枚举就是Vector特有的取出方式
2、发现枚举和迭代器很像。
3、其实枚举和迭代是一样的，
4、因为枚举的名称以及方法的名称都过长，所以被迭代器取代了，枚举就郁郁而终了

import java.util.*;

class Demo{

public static void main(String[] args){

method_get();

}

public static void method_get(){

Vector v = new Vector();

v.add("java01");

v.add("java02");

v.add("java03");

v.add("java04");

Enumeration en = v.elements();

while(en.hasMoreElements()){

sop(en.nextElement());

}

public static void sop(Object obj){

System.out.println(obj);

}

四、LinkedList
1、LinkedList:特有方法
(1)、addFirst()：
(2)、addLast()：
(3)、getFirst()：
(4)、getLast()：
(5)、removeFirst()：删除并返回元素，如果集合中没有有元素，会出现NoSuchElementExceptionextends RuntimeException 表明枚举中没有更多的元素。

peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
(5)、removeLast()
2、1.6中出现了替代方法
boolean offer(E e)

将指定元素添加到此列表的末尾（最后一个元素）。
boolean offerFirst(E e)
在此列表的开头插入指定的元素。
E peekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast()
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

五、ArrayList

System.Collections.ArrayList类是一个特殊的数组。通过添加和删除元素，就可以动态改变数组的长度。

一．优点

1. 支持自动改变大小的功能
2. 可以灵活的插入元素
3. 可以灵活的删除元素

二．局限性

跟一般的数组比起来，速度上差些

三．添加元素

1．publicvirtualintAdd(objectvalue);

将对象添加到ArrayList的结尾处

ArrayList aList = new ArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
内容为abcde

2．publicvirtualvoidInsert(intindex,objectvalue);

将元素插入ArrayList的指定索引处

ArrayList aList = new ArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Insert(0,"aa");

结果为aaabcde

3．publicvirtualvoidInsertRange(intindex,ICollectionc);

将集合中的某个元素插入ArrayList的指定索引处

ArrayList aList = new ArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
ArrayList list2 = newArrayList();
list2.Add("tt");
list2.Add("ttt");
aList.InsertRange(2,list2);

结果为abtttttcde

四．删除

1. publicvirtualvoidRemove(objectobj);

从ArrayList中移除特定对象的第一个匹配项,注意是第一个

ArrayList aList = new ArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Remove("a");

结果为bcde

2. publicvirtualvoidRemoveAt(intindex);

移除ArrayList的指定索引处的元素

aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.RemoveAt(0);

结果为bcde

3．publicvirtualvoidRemoveRange(intindex,intcount);

从ArrayList中移除一定范围的元素。Index表示索引，count表示从索引处开始的数目

aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.RemoveRange(1,3);

结果为ae

4．publicvirtualvoidClear();

从ArrayList中移除所有元素。

五．排序

a) publicvirtualvoidSort();

对ArrayList或它的一部分中的元素进行排序。

ArrayList aList=new ArrayList();
aList.Add("e");
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
DropDownList1.DataSource=aList;//DropDownListDropDownList1;
DropDownList1.DataBind();

结果为eabcd

ArrayList aList=new ArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();//排序
DropDownList1.DataSource=aList;//DropDownListDropDownList1;
DropDownList1.DataBind();

结果为abcde

b) publicvirtualvoidReverse();

将ArrayList或它的一部分中元素的顺序反转。

ArrayList aList=new ArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Reverse();//反转
DropDownList1.DataSource=aList;//DropDownListDropDownList1;
DropDownList1.DataBind();
结果为edcba

六．查找

a) publicvirtualintIndexOf(object);
b) publicvirtualintIndexOf(object,int);
c) publicvirtualintIndexOf(object,int,int);

返回ArrayList或它的一部分中某个值的第一个匹配项的从零开始的索引。没找到返回-1。

ArrayList aList = new ArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
intnIndex=aList.IndexOf(“a”);//1
nIndex=aList.IndexOf(“p”);//没找到，-1
d) publicvirtualintLastIndexOf(object);
e) publicvirtualintLastIndexOf(object,int);
f) publicvirtualintLastIndexOf(object,int,int);

返回ArrayList或它的一部分中某个值的最后一个匹配项的从零开始的索引。

ArrayList aList = new ArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("a");//同0
aList.Add("d");
aList.Add("e");
intnIndex=aList.LastIndexOf("a");//值为2而不是0

g) publicvirtualboolContains(objectitem);

确定某个元素是否在ArrayList中。包含返回true,否则返回false

六、HashSet

Set：元素是无序（存入和取出的顺序不一定一致）的，元素不可以重复

HashSet：底层数据结构是哈希表

HashSet是如何保证元素的唯一性的呢？

是通过元素的两个方法，hashCode和equals来完成。

如果元素的hashCode值相同，才会判断equals是否为true

如果元素的hashCode值不同，不会调用equals

注意：对于判断元素是否存在，以及删除的操作，以来的方法是元素的 hashCode和equals方法

先 hashCode 再 equals

而，arrayList 仅仅是equals

TreeSet：

Set集合的功能和Collection是一致的

import java.util.*;

public class Demo{

public static void main(String args[]){

HashSet hs = new HashSet();

hs.add("java01");

hs.add("java02");

hs.add("java03");

sop(hs.add("java04"));

for(Iterator it = hs.iterator();it.hasNext();){

sop(it.next());

}

public static void sop(Object obj){

System.out.println(obj.toString());

}

七：二叉树TreeSet

Set:无序，不可以重复元素

HashSet:数据结构是哈希表，线程是非同步

保证元素唯一的原理：判断元素的HashCode值是否相同。

如果相同，还会继续判断元素的equals方法，是否为true

TreeSet:可以对Set集合中的元素进行排序，按照Asiic

底层数据结构是二叉树

保证元素唯一性的依据

compareTo 方法 return 0,表明数据相同

TreeSet 排序的第一种方式：让元素自身具备比较性

元素需要实现 Comparable 接口，覆盖compareTo方法

这种方式也称为元素的自然顺序，或者默认顺序。

需求：往 TreeSet 集合中存储自定义对象学生。

想按照学生的年龄进行排序

public interface Comparable<T>此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

如果返回0，表明这两个对象相等，不存储

记住：排序时，当主要条件相同时，一定判断一下次要条件

HashSet如果是对象，需要重写equals，但是TreeSet存的时候会判断大小，相当于判断是否相当，所以不用重写equals

如果想要按照存入书顺序取出

可以让 compareTo 恒返回 1；这样存在于二叉树的右侧，就可以了

import java.util.*;

public class Demo{

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("lisi02",40));

ts.add(new Student("lisi01",40));

for(Iterator it = ts.iterator();it.hasNext();){

Student s = (Student)it.next();

sop(s.getName()+" :: "+s.getAge());

}

public static void sop(Object obj){

System.out.println(obj.toString());

}

class Student implements Comparable{

private String name;

private int age;

Student(String name,int age){

this.name = name;

this.age = age;

}

public String getName(){

return name;

}

public int getAge(){

return age;

}

//如果返回0，表明这两个对象相等，不存储

public int compareTo(Object obj){

if(!(obj instanceof Student)){

throw new RuntimeException("不是学生对象");

}

Student s = (Student)obj;

int num = this.age-s.age;

if(num==0){

return this.getName().compareTo(s.getName());

}else{

return num;

}

另外：实现Comparator方式排序

TreeSet的第二种排序方式

当元素自身不具备比较性时，或者具备的比较性不是所需要的时候。

这时候需要让集合自身具备比较性

在集合初始化时，就有了比较方式。

定义一个比较器，将比较器对象作为参数，传递给 TreeSet 集合的构造函数

当两种方式都存在时候，以比较器为主

此处代码略。

八：泛型

泛型：jdk1.5 以后出现的新特性，用于解决安全问题，是一个安全机制

好处：

1、将运行时期出现的问题 classCastException，转移到了编译时期

方便于程序员解决问题。让运行时期问题减少，安全。

2、避免了强制转换的麻烦

泛型格式：通过 <> 来定义要操作的引用数据类型。

什么时候使用泛型呢？

通常在集合框架中很常见

只要见到<>就要定义泛型

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

当使用集合时，将集合中要存储的数据类型作为参数传递到尖括号中即可，和函数传参数一样

泛型类

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候

早起定义Object 来完成扩展

现在，定义泛型来完成扩展。

代码如下：

import java.util.*;

public class Demo{

public static void main(String args[]){

//泛型出现以前的做法

Tool t = new Tool();

//可以传入 worker

t.setObject(new Worker());

t.getObject();

//可以传入Student

t.setObject(new Student());

t.getObject();

//泛型出现以后的做法

Utils<Worker> u = new Utils<Worker>();

u.setObject(new Worker());

Worker w = u.getObject();

}

public static void sop(Object obj){

System.out.println(obj.toString());

}

class Worker{

}

class Student{

}

//泛型出现以前的做法

class Tool{

private Object o;

public void setObject(Object o){

this.o = o;

}

public Object getObject(){

return o;

}

//泛型出现后，用泛型的做法

//泛型类

class Utils<E>{

private E o;

public void setObject(E o){

this.o = o;

}

public E getObject(){

return o;

}

九：泛型方法

泛型类定义的泛型，在整个类中有效，如果被方法是用

那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了

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

那么可以将泛型定义在方法上，而不定义在类上

public <T> void show(T t){

}

另外：静态方法泛型

泛型类中也可以定义泛型方法
特殊之处：静态方法不可以访问类上定义的泛型，因为只有在实例化的时候，才会使用泛型
如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上
<T> 泛型写在返回值前

public static <T> void setName(T t){

}

泛型类代码示例：

import java.util.*;

public class Demo{

public static void main(String args[]){

//泛型确定

GenericDemo<String> d = new GenericDemo<String>();

d.show("haha");

d.print("hehe");

//泛型不确定

GenericDemo_2 d_2 = new GenericDemo_2();

d_2.show("haha");

d_2.print(new Integer(4));

d_2.print(4);

}

public static void sop(Object obj){

System.out.println(obj.toString());

}

//类型已经确定

class GenericDemo<T>{

public void show(T t){

sop("show:"+t);

}

public void print(T t){

sop("print:"+t);

}

public static void sop(Object obj){

System.out.println(obj.toString());

}

//类型不确定，使用泛型方法

class GenericDemo_2{

//泛型方法

public <Q> void show(Q q){

sop("show_2:"+q);

}

public <Q> void print(Q q){

sop("print_2:"+q);

}

public static void sop(Object obj){

System.out.println(obj.toString());

}

十：泛型限定

通配符

import java.util.*;

public class Demo{

public static void main(String args[]){

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

al.add("abc");

al.add("sadf");

al.add("sa");

ArrayList<Integer> al1 = new ArrayList<Integer>();

al1.add(1);

al1.add(2);

al1.add(3);

printColl(al);

printColl(al1);

}

public static void printColl(ArrayList<?> al){

Iterator<?> it = al.iterator();

while(it.hasNext()){

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

}

? 通配符

? extends E:可以接收 E 类型或者 E 的子类型。上限。

？ super E：可以接收E类型或者E的父类型，下限

import java.util.*;

public class Demo{

public static void main(String args[]){

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

al.add(new Person("abc"));

al.add(new Person("dsf"));

al.add(new Person("absdc"));

ArrayList<Student> al1 = new ArrayList<Student>();

al1.add(new Student("abc"));

al1.add(new Student("dsf"));

al1.add(new Student("absdc"));

//printColl(al1);这是错误的，不能直接写

}

//public static void printColl(ArrayList<Person> al){ 这样只能接受person

public static void printColl(ArrayList<? extends Person> al){//这样可以接收别的子类

Iterator<Person> it = al.iterator();

while(it.hasNext()){

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

}

class Person{

private String name;

Person(String name){

this.name = name;

}

public String getName(){

return name;

}

class Student extends Person{

Student(String name){

super(name);

}

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

jiayanxing1989

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-集合框架Collection的若干知识点

------- http://www.itheima.com" target="blank">android培训、http://www.itheima.com" target="blank">java培训、期待与您交流！ ----------概述：所有集合类都位于java.util包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。
复制链接

扫一扫