黑马程序员——12JavaAPI集合类

最新推荐文章于 2018-05-17 19:30:52 发布

itburn

最新推荐文章于 2018-05-17 19:30:52 发布

阅读量436

点赞数

分类专栏：黑马程序员文章标签：黑马程序员 Java API集合类 xuefei

本文链接：https://blog.csdn.net/mengjing126105/article/details/8966441

版权

黑马程序员专栏收录该内容

20 篇文章 0 订阅

订阅专栏

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

1，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，它们的区别是：

数组虽然也可以存储对象，但长度是固定的；

集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同数据类型的对象。

2，出现这么多容器，因为每一个容器对数据的存储方式都有不同。这个存储方式我们称之为：数据结构。

集合框架：

集合体系：

3， Collection定义了集合框架的共性功能，集合中存储的都是对象的引用(地址) 。

          1）添加

         add(e); // add方法的参数类型是Object。以便于接收任意类型对象。

           addAll(collection);

          2）删除

         remove(e);

         removeAll(collection);

         clear();

          3）判断。

         contains(e);

         isEmpty();

          4）获取

          iterator();

          size();

          5）获取交集。

          retainAll();

          6）集合变数组。

          toArray();

4，迭代器 Iterator的原理：

迭代器其实就是集合的取出元素的方式，会直接访问集合中的元素，所以将迭代器通过内部类的形式来进行描述。通过容器的iterator()方法获取该内部类的对象。

class CollectionDemo {

public static void main(String[] args) {

ArrayList al = new ArrayList();

//1，添加元素。

al.add("java01");    //add(Object obj);

              /* Iterator it = al.iterator();    //获取迭代器，用于取出集合中的元素。

while(it.hasNext()) {

sop(it.next());

}*/

                  //应用for形式，迭代器用完即释放。更节省内存。

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

sop(it.next());

}

}

}

5，集合类的比较与总结：

1）Collection，List，Set，Map都属于集合框架中的接口。

Collection，Map是顶层接口。List，Set继承Collection接口。

2）List：列表，元素是有序的(元素带角标索引)，可以有重复元素，可以有null元素。

Set：集合，元素是无序的(因为没有索引)，元素不可以重复。可以有null元素。

Map：顶层接口，该集合存储的是键值对，而且键是唯一的。

3）Map和Set很像，因为 Set集合底层就是使用了Map集合。

Map集合没有迭代器，要取出元素必须先将Map集合转换成Set集合才能遍历元素。

4）实现List接口的常用类：

4. 1)，ArrayList(JDK1.2)：

底层的数据结构：数组数据结构。

特点：查询速度快(因为带角标)，但是增删速度稍慢,因为当元素多时，增删一个元素则所有元素的角标都得改变，线程不同步。默认长度是10，当超过长度时，按50%延长集合长度。

4. 2)，LinkedList(JDK1.2)：

底层数据结构：链表数据结构(即后面一个元素记录前一个)。

特点：查询速度慢，因为每个元素只知道前面一个元素，但增删速度快，因为元素再多，增删一个，只要让其前后的元素重新相连即可，线程是不同步的。

4.3)，Vector(JDK1.0)：

底层数据结构：数组数据结构。

特点：查询和增删速度都很慢。默认长度是10，当超过长度时,按100%延长集合长度。线程同步。

注意： Vector功能跟ArrayList功能一模一样，已被ArrayList替代。

5）实现Set接口的常用类：

5.1)，HashSet(JDK1.2)：

底层数据结构：哈希表。

特点：存取速度快，元素唯一，线程不同步。

保证性元素唯一的原理：

先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true。

注意：往HashSet里面存的自定义元素要复写hashCode和equals方法，以保证元素的唯一性。

5. 2)，TreeSet(JDK1.2)：

底层数据结构：二叉树。

特点：可以对Set集合中的元素进行排序。元素有序，线程不同步。

保证元素唯一性的依据：compareTo方法return 0。

TreeSet排序的第一种方式：

让元素自身具备比较性，比如八种基本数据类型或则字符串，实现Compareble接口，覆盖compareTo方法，此方式是元素的自然顺序。

TreeSet排序的第一种方式：

当元素自身不具备比较性(比如存储学生对象时)或者具备的比较性不是我们所需要的比较性时(比如想字符串的长度排序)，此时就需要让集合自身具备自定义的比较性。可在集合初始化时，就让集合具备比较方式。即定义一个类，实现Comparator接口，覆盖compare方法。

6）实现Map接口的常用类：

6. 1)，HashTable(JDK1.0)：

底层数据结构：哈希表。

特点：不可以使用null键和null值，线程同步，效率低。

注意：用作键的对象必须实现hashCode和equals方法来保证键的唯一性。

6. 2)，HashMap(JDK1.2)：

底层数据结构：哈希表。

特点：允许使用null键和null值，线程不同步，效率高；

保证元素唯一性的原理：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true。

6. 3)，TreeMap(JDK1.2)：

底层数据结构：二叉树。

特点：允许使用null键和null值，线程不同步，可以给Map集合中的键进行排序。

TreeMap排序的第一种方式：

让元素自身具备比较性，比如八种基本数据类型或则字符串，实现Compareble接口,覆盖compareTo方法，此方式是元素的自然顺序。

TreeMap排序的第一种方式：

6， List：特有方法，凡是可以操作角标的方法都是该体系特有的方法。

增 add(index,element);

addAll(index,Collection);

删 remove(index);

改 set(index,elenment);

查 get(index);

subList(from,to);

listIterator();

在迭代时，不可以通过集合对象的方法操作集合中的元素，因为集合和迭代器同时拥有元素对象的引用。此时迭代器去操作集合，有可能发生并发修改异常，即 ConcurrentModificationException异常。

如果想要其他的操作如添加，修改等，就需使用 Iterator的子接口 ListIterator， List集合特有的迭代器。

该接口只能通过List集合的listIterator方法获取。

import java.util.*;

class ListDemo {

public static void main(String[] args) {

ArrayList al=new ArrayList();

//添加元素

al.add("java01");

al.add("java02");

System.out.println ("原集合是："+al);

for( al.listIterator() ;li.hasNext();) {

System.out.println ("hasPrevious:"+li.hasPrevious());

Object obj=li.next();

if(obj.equals("java02")) {

li.set("java006");

li.add("java009");

}

System.out.println("hasNext():"+li.hasNext());

System.out.println ("hasPrevious:"+li.hasPrevious());

}

7，枚举就是Vector特有的取出方式，其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

import java.util.*;

class VectorDemo {

public static void main(String[] args) {

Vector v=new Vector();

v.add("java01");

v.add("java02");

for(Enumeration en=v.elements();en.hasMoreElements();) {

System.out.println(en.nextElement());

}

8， LinkedList：

特有方法：

addFirst();

addLast();

getFirst();

getLast();获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementExceptionremoveFirst();

removeLast();获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法。

offerFirst();

offerLast();

peekFirst();

peekLast();获取元素，但不删除元素。如果集合中没有元素，会返回null

pollFirst();

pollLast();获取元素，但是元素被删除。如果集合中没有元素，会返回null

使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出FILO

队列：先进先出FIFO

import java.util.*;

class Queue{

private LinkedList link;

Queue(){

link=new LinkedList();

}

public void myAdd(Object obj) {

//头插法，保证先进先出。

link.addFirst(obj);

}

public Object myGet() {

return link.removeLast();

}

public boolean isNull(){

return link.isEmpty();

}

class LinkedListTest{

public static void main(String[] args) {

Queue d=new Queue();

d.myAdd("java01");

d.myAdd("java02");

while(!d.isNull()){

System.out.println(d.myGet());

}

9，1）ArrayList保证元素唯一，即去除重复元素。需要定义一个临时容器，用contains方法判断，同时需要复写equals方法。

public static ArrayList singleElement(ArrayList al){

//定义一个临时容器。

ArrayList newAl=new ArrayList();

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

Object obj=it.next();

if(!newAl.contains(obj))

newAl.add(obj);

}

return newAl;

}

2）HashSet保证元素唯一。复写hashCode()，equals(Object obj)方法。

public int hashCode() {

return name.hashCode()+age*39; //扩大范围，避免出现重复值

}

public boolean equals(Object obj){ //注意：此处参数必须是Object，才能复写Object类中的equals方法。

if(!(obj instanceof Person))

return false;

Person p=(Person)obj;

return this.name.equals(p.name)&&this.age==p.age;
}

10，当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较器。

当两种排序都存在时，以比较器为主。

class TreeSetDemo{

public static void main(String[] args){

//将自定义的比较器作为参数传递给TreeSet构造函数。

TreeSet<Student> ts=new TreeSet<Student>(new MyCompare());

ts.add(new Student("lisi02",22));

ts.add(new Student("lisi007",20));

ts.add(new Student("lisi09",19));

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

Student s=it.next();

System.out.println(s.getName()+'\t'+s.getAge());

}

//第二种排序方法，自定义一个比较器，当两种排序同时存在时，此种方法生效。

class MyCompare implements Comparator<Student>{

//复写compare 方法。

public int compare(Student o1,Student o2){

//此处使用泛型，不用强转。

//Student s1=(Student)o1;

//Student s2=(Student)o2;

if(!o1.getName().equals(o2.getName()))

return o1.getName().compareTo(o2.getName());

else

return new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));

}

//第一种排序方法，强制让学生具备比较性。

class Student implements Comparable<Student>{

private String name;

private int age;

Student(String name ,int age){

this.name=name;

this.age=age;

}

//复写compareTo方法。

public int compareTo(Student obj){

if(!(obj instanceof Student))

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

Student s=(Student)obj;

System.out.println(this.name+"..compareTo.."+obj.name);

if(this.age!=obj.age)

return this.age-obj.age;//降序为s.age-this.age

else

return this.name.compareTo(obj.name); //降序为s.name.compareTo(this.name);

}

11，泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制。

好处：1）将运行时期出现的问题ClassCastException，转移到编译时期。方便于程序员解决问题。让运行时期问题减少。

2）避免了强制转换的麻烦。

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

在使用java提供的对象时，泛型，通常在集合框架中很常见。

只要见到<>就要定义泛型，其实<>就是用来接收类型的。

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

class GenericDemo{

public static void main(String[] args){

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

al.add("abc01");

//al.add(new Integer(4)); //编译时报错，泛型在编译时期检查类型。

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

String s=it.next();

System.out.println(s+'\t'+":"+s.length());

}

12，自定义泛型。

1）泛型定义在类上。

当类中要操作的引用数据类型不确定时，早期定义Object来完成扩展，现定义泛型来完成扩展。

class Utils<Q>{

private Q q;

public void setObject(Q q){

this.q=q;

}

public Q getObject(){

return q;

}

2）泛型定义在方法上。方法声明泛型应紧靠返回值的前面。
泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

class Demo<T>{ //泛型类

public void show(T t){

System.out.println("show:"+t);

}

public <Q>void print(Q q){ //泛型方法。

System.out.println("print:"+q);

}

public static <W>void method(W t){ //泛型定义在静态方法上。

System.out.println("method:"+t);

}

特殊之处：静态方法不可以访问类上定义的泛型。因为类上的泛型只对该类的对象有效。

                                  如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
            3）泛型定义在接口上。
   interface Inter<T> {
                                     void show(T t);
   }
class InterImpl<T> implements Inter<T> {
public void show(T t) {
System.out.println("show:"+t);
}
}

13， ?通配符，也可以理解为占位符。
泛型的限定：
？extends E:可以接收E类型或者E的子类。上限。
？super E:可以接收E类型或者E的父类型。下限。
public static void printColl(ArrayList<?> al) {
                 for(Iterator<?> it=al.iterator();it.hasNext();) {
                 System.out.println(it.next());
//.length()不可以，具体的类型方法。
//.toString()可以，所有对象都具备此方法。
                 }
                 }

14 ， Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。
                 1）添加。
put(K key,V value); //注意此处添加为put。
putAll(Map<? extends K,? extends V> m);
2）删除。
clear();
remove(Object key);
3）判断。
containsKey(Object key);
containsValue(Object value);
isEmpty();
4）获取。
get(Object key);
size();
values();
entrySet();
keySet();
   Map集合的取出原理：将map集合转成Set集合，再通过迭代器取出。
Map集合的两种取出方式：
1)Set<K> keySet：
将Map中所有的键存入到Set集合，因为set具备迭代器，所以可以用迭代方式取出所有的键，
再根据get方法，获取每一个键对应的值。

//先获取map集合中的所有键的Set集合，keySet();
                                 Set<String> keySet=map.keySet();
                                 //有了Set集合就可以获取其迭代器。
                                 for(Iterator<String> it=keySet.iterator();it.hasNext();) {
                                 String key=it.next();
                                 //有了键就可以通过Map集合的get方法获取其对应的值。
                                 String value=map.get(key);
                                 System.out.println("key:"+key+"...value:"+value);
                      }
   2)Set<Map.Entry<K,V>> entrySet：将map集合中的映射关系存入到set集合中，而这个关系的数据类型就是：Map.Entry。
   //将Map集合中的映射关系取出，存入到Set集合中。
   Set<Map.Entry<String,String>> entrySet=map.entrySet();
   for(Iterator<Map.Entry<String,String>> it=entrySet.iterator();it.hasNext();) {
   Map.Entry<String,String> me=it.next();
                                 String key=me.getKey();
                                 String value=me.getValue();
                                 System.out.println(key+":::"+value);
                                 }

15，其他API。
1）集合框架的工具类 Collections
二分查找： binarySearch(List<? extends Comparable<? super T>> list, T key)
替换列表中的所有元素： fill ( List <? super T> list, T obj)

2）集合变数组：toArray();
目的：为了限定对元素的操作。不需要进行增删。
   String[] s=al.toArray(new String[al.size()]);
// 当指定的数组长度小于了集合的size,那么该方法内部会创建一个新的数组
                     Arrays.toString(s);

3）高级for循环，JDK1.5的新特性。
格式： for(数据类型变量名：被遍历的集合（Collection）或者数组) { }
   对集合进行遍历，只能获取元素，不能对集合进行操作。
   迭代器除了遍历，还可以remove集合中元素的动作。如果使用ListIterator，还可以在遍历过程中进行增删改查的动作。
   传统for和高级for的区别：高级for有一个局限性，必须有被遍历的目标。
建议在遍历数组的时候，还是希望使用传统for,因为传统for可以定义角标。

                        4）方法的可变参数， JDK1.5版本的新特性。
                             在使用是注意：可变参数一定定义在参数列表的最后边。
                               public static void show(int... arr) {
                                     System.out.println(arr.length);
                              }

                        5） StaticImport 静态导入，JDK1.5的新特性。
                              import java.util.*;
                               //导入Arrays这个类中的所有静态成员。
                              import static java.util.Arrays.*;
                               //导入了System类中所有的静态成员。
                              import static java.lang.System.*;
                              class StaticImport{
                                      public static void main(String[] args){
                                                out.println("haha");
                                                int[] arr={3,1,5};
                                                sort(arr);
                                                int index=binarySearch(arr,1);
                                                out.println(Arrays.toString(arr));
                                                out.println("Index:"+index);
                                       }
                                }
                            注意：当类名重名时，需要制定具体的包名。
                                             当方法重名时，需要指定具体所属的对象或者类。

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

详情请查看：http://edu.csdn.net/heima

itburn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——12JavaAPI集合类

------------android培训、java培训、期待与您交流！------------ 1，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。数组和集合类同是容器，它们的区别是：数组虽然也可以存储对象，但长度是固定的；集合长
复制链接

扫一扫