黑马程序员_java集合概述

原创 2015年07月09日 22:00:48

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

一,集合类

1.为什么出现集合类?

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

2.数组和集合类同是 容器,有何不同?

数组虽然也可以存储对象,但长度是固定的,集合长度是可变的,数组中可以存储基本数据类型,集合只能存储对象。

3.集合类的特点

集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。

二,集合框架

1.Collection:

add  rmove contains clear iterator

2.List

ArrayList   LinkList vector

3.set

HashSet TreeSet

4.Collection定义了集合框架的共性功能。
4.1,添加
add(e);
addAll(collection);


4.2,删除
remove(e);
removeAll(collection);
clear();


4.3,判断。
contains(e);
isEmpty();


4.4,获取
iterator();
size();


4.5,获取交集。
retainAll();


4.6,集合变数组。
toArray();

4.7add方法的参数类型是Object。以便于接收任意类型对象。


4.8集合中存储的都是对象的引用(地址).

5.迭代器:

其实就是集合取出元素的方式,

迭代器是取出方式,会直接访问集合中的内部元素。

所以迭代器通过内部类的方式来描述

通过迭代器的Iterator()方法来获取该内部类的对象

[java] view plaincopy
  1. class  CollectionDemo  
  2. {  
  3.     public static void main(String[] args)   
  4.     {  
  5.           
  6.         method_get();  
  7.     }  
  8.     public static void method_get()  
  9.     {  
  10.         ArrayList al = new ArrayList();  
  11.   
  12.         //1,添加元素。  
  13.         al.add("java01");//add(Object obj);  
  14.         al.add("java02");  
  15.         al.add("java03");  
  16.         al.add("java04");  
  17.   
  18.         /* 
  19.         Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素。 
  20.  
  21.         while(it.hasNext()) 
  22.         { 
  23.             sop(it.next()); 
  24.         } 
  25.         */  
  26.   
  27.         for(Iterator it = al.iterator(); it.hasNext() ; )  
  28.         {  
  29.             sop(it.next());  
  30.         }  
  31.     }  
  32.   
  33.   
  34.     public static void method_2()  
  35.     {  
  36.         ArrayList al1 = new ArrayList();  
  37.   
  38.         al1.add("java01");  
  39.         al1.add("java02");  
  40.         al1.add("java03");  
  41.         al1.add("java04");  
  42.         ArrayList al2 = new ArrayList();  
  43.   
  44.         al2.add("java03");  
  45.         al2.add("java04");  
  46.         al2.add("java05");  
  47.         al2.add("java06");  
  48.   
  49.           
  50.         //al1.retainAll(al2);//去交集,al1中只会保留和al2中相同的元素。  
  51.         al1.removeAll(al2);  
  52.   
  53.         sop("al1:"+al1);  
  54.         sop("al2:"+al2);  
  55.   
  56.   
  57.   
  58.   
  59.     }  
  60.   
  61.     public static void base_method()  
  62.     {  
  63.         //创建一个集合容器。使用Collection接口的子类。ArrayList  
  64.         ArrayList al = new ArrayList();  
  65.   
  66.         //1,添加元素。  
  67.         al.add("java01");//add(Object obj);  
  68.         al.add("java02");  
  69.         al.add("java03");  
  70.         al.add("java04");  
  71.   
  72.         //打印原集合。  
  73.         sop("原集合:"+al);  
  74.   
  75.   
  76.         //3,删除元素。  
  77.         //al.remove("java02");  
  78.         //al.clear();//清空集合。  
  79.   
  80.   
  81.         //4,判断元素。  
  82.         sop("java03是否存在:"+al.contains("java03"));  
  83.         sop("集合是否为空?"+al.isEmpty());  
  84.   
  85.   
  86.         //2,获取个数。集合长度。  
  87.         sop("size:"+al.size());  
  88.   
  89.         //打印改变后的集合。  
  90.         sop(al);  
  91.   
  92.     }  
  93.   
  94.     public static void sop(Object obj)  
  95.     {  
  96.         System.out.println(obj);  
  97.     }  
  98. }  
List集合特有的迭代器,ListIterator是Iterator的子接口

Collection
|--List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点:增删速度很快,查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。




|--Set:元素是无序,元素不可以重复。、

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

在迭代时,不可以通过集合对象的方法操作集合中的元素

因为会发生ConcurrentModificatioException异常。

所以,在迭代器时,只能用迭代器的放过操作元素,可是Iterator方法是有限的,

只能对元素进行判断,取出,删除的操作,

如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator.

该接口只能通过ListIterator方法获取。

[java] view plaincopy
  1. import java.util.*;  
  2. class ListDemo   
  3. {  
  4.     public static void sop(Object obj)  
  5.     {  
  6.         System.out.println(obj);  
  7.     }  
  8.     public static void method()  
  9.     {  
  10.           
  11.         ArrayList al = new ArrayList();  
  12.   
  13.         //添加元素  
  14.         al.add("java01");  
  15.         al.add("java02");  
  16.         al.add("java03");  
  17.           
  18.         sop("原集合是:"+al);  
  19.         //在指定位置添加元素。  
  20.         al.add(1,"java09");  
  21.   
  22.         //删除指定位置的元素。  
  23.         //al.remove(2);  
  24.   
  25.         //修改元素。  
  26.         //al.set(2,"java007");  
  27.   
  28.         //通过角标获取元素。  
  29.         sop("get(1):"+al.get(1));  
  30.   
  31.         sop(al);  
  32.   
  33.         //获取所有元素。  
  34.         for(int x=0; x<al.size(); x++)  
  35.         {  
  36.             System.out.println("al("+x+")="+al.get(x));  
  37.         }  
  38.   
  39.         Iterator it = al.iterator();  
  40.   
  41.         while(it.hasNext())  
  42.         {  
  43.             sop("next:"+it.next());  
  44.         }  
  45.   
  46.   
  47.         //通过indexOf获取对象的位置。  
  48.         sop("index="+al.indexOf("java02"));  
  49.   
  50.         List sub = al.subList(1,3);  
  51.   
  52.         sop("sub="+sub);  
  53.     }  
  54.   
  55.       
  56.     public static void main(String[] args)   
  57.     {  
  58.   
  59.         //演示列表迭代器。  
  60.         ArrayList al = new ArrayList();  
  61.   
  62.         //添加元素  
  63.         al.add("java01");  
  64.         al.add("java02");  
  65.         al.add("java03");  
  66.   
  67.         sop(al);  
  68.   
  69.           
  70.         ListIterator li = al.listIterator();  
  71.   
  72.           
  73.         //sop("hasPrevious():"+li.hasPrevious());  
  74.   
  75.         while(li.hasNext())  
  76.         {  
  77.             Object obj = li.next();  
  78.   
  79.             if(obj.equals("java02"))  
  80.                 //li.add("java009");  
  81.                 li.set("java006");  
  82.   
  83.   
  84.         }  
  85.   
  86.         while(li.hasPrevious())  
  87.         {  
  88.             sop("pre::"+li.previous());  
  89.         }  
  90.         //sop("hasNext():"+li.hasNext());  
  91.         //sop("hasPrevious():"+li.hasPrevious());  
  92.   
  93.   
  94.         sop(al);  
  95.   
  96.   
  97.   
  98.         /* 
  99.         //在迭代过程中,准备添加或者删除元素。 
  100.  
  101.         Iterator it = al.iterator(); 
  102.  
  103.         while(it.hasNext()) 
  104.         { 
  105.             Object obj = it.next(); 
  106.  
  107.             if(obj.equals("java02")) 
  108.                 //al.add("java008"); 
  109.                 it.remove();//将java02的引用从集合中删除了。 
  110.  
  111.             sop("obj="+obj); 
  112.  
  113.  
  114.         } 
  115.         sop(al); 
  116.         */  
  117.           
  118.   
  119.   
  120.     }  
  121. }  
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

黑马程序员_日记30_Java集合框架概述

——- android培训、java培训、期待与您交流! ———-集合框架概述正如数据被封装在对象里面,对象则封装在集合。 所以,集合就是对象的一种存储方式。数组也可以存储对象,那么数组和集合的区别...

黑马程序员--Java学习日记之集合(collection类与list接口)及泛型概述

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 一,集合概念   之前我们存储大量的对象,可以使用数组:   但数组有两个缺陷:   1.其...

黑马程序员-Java 集合框架(一)-概述、List、Set

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-一、概述集合框架是用于储存数组的容器,具有统一的父类接口Collection,主要的集合关系类如下图: 然而集合...

黑马程序员——JAVA基础——集合---概述、Collection中共性方法、List、Map、工具类Collections和Arrays

-----------android培训、java培训、java学习型技术博客、期待与您交流!------------

黑马程序员——Java语言基础——06.集合框架(1)集合框架概述和List、Set集合

------- android培训、java培训、期待与您交流! ---------- 集合框架:用于存储数据的容器。 本节考点: 一、集合和数组的区别 二、说一说集合框架体系,Lis...

黑马程序员_JAVA学习之概述

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

黑马程序员——第一天(Java概述)

---------------------- android培训、java培训、期待与您交流! ---------------------- 1.常见DOS命令 dir:  列出当前目录下...

黑马程序员 java概述与基础知识<二>

-----------android培训、java培训、java学习型技术博客、期待与您交流! ------------ for循环和while循环的特点:1,for和while可以互换;2,格式上的...

黑马程序员——Java概述

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——- 一、前奏 学习Java语言之前,先要掌握一些常用的dos命令,如: dir:列出当前目录下的文件以及文件夹...

黑马程序员-----JAVA的概述

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流! ----------------------
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)