关于java基础--集合部分测试与详解

1,集合

集合:就是跟数组一样是存放数据的容器

集合与数组的区别:

 数组在声明的时候就已经固定了能存放的数据类型并且不能自动对存放的数据进行一些排序,算法等.

 集合也是一个容器.它默认的能存放任何类型的数据(不能存放八大基本数据类型)对于那些基本数据类型的数值,它会自动打包成对应的封装类,然后再添加进去.

 集合会对一些数据进行某些算法操作.

2,Collection接口

 * 所有的集合的根节是Collection和Map

 * Collection下面的子接口有Set和List

public class TestCollection {

public static void testCollection(){

//创建一个HashSet集合,它的引用赋给Collection

Collection co = new HashSet();

2-1,add()添加元素

co.add("a");

co.add(1);

co.add(12.3);

co.add("美女你好");

2-2,是否包含contains()

boolean b1 = co.contains(1);//因为1在里面所以返回true

System.out.println(b1);

co.add(new a());

co.add(new a());

co.add(new String("美女你好"));

2-3,equqles 和集合中已有的对象进行比较

boolean b2 = co.equals("美女你好");

System.out.println("co.equals美女你好 "+b2);

//打印hashCode

System.out.println(co.hashCode());

//判断此集合元素是否为空,空true,否则false

boolean b3 = co.isEmpty();

2-4,remove()移除指定的元素

co.remove("a");

返回集合长度

int size = co.size();

创建一个集合

Collection book = new HashSet();

book.add("java");

book.add("web");

book.add("javaScript");

把book添加到co中

co.addAll(book);

判断当前集合中有没有包含另外指定的集合

Boolean b4 = co.containsAll(book);

2-4,retainAll()删除除了指定集合外的元素

boolean b6 = co.retainAll(book);

删除指定的集合,删除成功返回true,不成功false

boolean b5 =co.removeAll(book);

2-5,iterator()遍历集合中的元素

把集合中的元素copy一份到iterator(迭代器),然后通过迭代器把集合中的元素遍历出来(打印出来)

步骤:(1),创建遍历器iterator()

     (2),判断遍历器内是否含有下一个元素hasNext()

     (3),取出当前指针的元素Next()

例题:删除集合元素

Iterator ite =co.iterator();

while(ite.hasNext()){

Object obj = ite.next();

if(obj==(Integer)1){

ite.remove();

}else 

System.out.print(obj+" ")

}

3,Set接口

 * 测试Set集合

 * Set中不能放重复的元素,因为Set集合是无序的

 * Set集合怎么判断两个添加的元素是否一样呢?是用equals方法判断

 * 如果返回为true就说明集合中有当前对象,如果返回false则没有

public void hashSetTest(){

//声明创建Set集合

Set<Person> set = new HashSet<Person>();

Person p1 = new Person();

p1.setName("李氏");

Person p2 = new Person();

Person p3 = new Person();

//往集合中添加元素

set.add(p1);

p1.setName("张三");

//添加重复的

set.add(p1);

//遍历集合

for(Person p:set){

System.out.println(p.getName());

}

}

4,LinkesHashSet

 * 它与hashset是父类与子类的关系

 * hashset是无序且不能重复,linkeshashset是通过链表连接,所以可以说是有序的;

5,List接口

 *list 是一个接口,一般用arrayList 去指向他的引用

 *list 有索引,有顺序,所以可以存放重复的元素

5-1,subList(x, y)截取指定的集合,返回子集合

第一个x:从哪一个索引开始.

第二个y:到哪结束,不包含

subList(0, 2)从指定的索引开始截取到指定的结束处但是不包含

 System.out.println(list.subList(0, 2));

5-2,toArray()把指定的集合转换成数组

Object[] str = list.toArray();

System.out.println(""+str[0]+"  "+str[1]);

5-3,遍历集合的方法

(1)用for循环遍历

for(int i = 0;i< list.size();i++){

System.out.print("   "+list.get(i));

}

(2)使用foreach遍历

for(String str2:list){

System.out.print("   "+str2);

}

(3)用迭代器

Iterator<String> ite = list.iterator();

while(ite.hasNext()){

String str3 = ite.next();

System.out.print("  "+str3);

}

5-4,List集合的逆向遍历

要想逆向遍历必须先进行正向遍历把指针移到最后  ,要不然就不执行

步骤:(1),创建逆向遍历器listIterator()

(2)正像遍历集合把指针指向最后hasNext(),next()

(3)逆向遍历集合hasPrevious(),previous()

例题:

ListIterator<String> listite =  list.listIterator();

//正向遍历迭代器

while(listite.hasNext()){//判断是否有上一个元素,有了返回true

System.out.print(listite.next()+"  ");

//结果:你好  c  k  d  e  f  e 

}

//逆向遍历迭代器

while(listite.hasPrevious()){

//取出值

System.out.print(listite.previous());

//结果:efedkc你好

}

5-5,测试固定List长度时添加会省时间

在创建list时就开辟空间,节省每次都要开辟空间的时间

测试添加十万个元素的时候,普通的list集合与指定容量的list集合的速度

(1)普通的list所需要的时间

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

long s1 = System.currentTimeMillis();

for(int i=0;i<100000;i++){

list1.add(i+"");

}

long e1 = System.currentTimeMillis();

System.out.println("普通list一共用时间"+(e1-s1));

(2)定义一个用固定容量的list集合

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

//设置list2集合的初始容量

list2.ensureCapacity(100000);

long s2 = System.currentTimeMillis();

for(int i=0;i<100000;i++){

list2.add(i+"");

}

long e2 = System.currentTimeMillis();

System.out.println("固定容量list一共用时间"+(e2-s2));

5-6,固定元素的集合.不能进行增删改

List<String> list4 = Arrays.asList("a","b","c","d","e");

//报错,不支持添加,删除.只支持查询

//list4.add("f");//java.lang.UnsupportedOperationException

//遍历固定的元素集合list4

for(String msg:list4){

System.out.print(msg+"  ");

}

5-7,倒序排列一个List类

int s=list4.size();

for(int i=0;i<s/2;i++){

list4.set(s-1-i, list4.set(i,list4.get(s-1-i)));

/*实质:

String a1=list.get(i);

String a2=list.get(s-1-i);

list.set(i, a2);

list.set(s-1-i, a1);

*/

}

for(String msg:list4){

System.out.print(msg+"  ");

}

6,Map<key,value>

 *Map是一个接口.重用的实现类是HashMap

 *map集合中保存的是键--值(Key-Value)

 *Key 相当于数组中的索引,不能重复.但是Value的值是可以重复的

 *一个Key只能对应一个Value 

6-1,put()添加元素

创建一个map集合

Map<String, String> map = new HashMap<String, String>();

map.put("a", "张三");

map.put("b", "李氏");

6-2,get(Key)取出Value值

String value = map.get("a");

//打印key所对应的value值

System.out.println(value);

6-3,containsKey()判断指定的map集合中是否包含指定的key值

Boolean b = map.containsKey("a");

System.out.println("指定集合map中是否包含a  :"+b);

6-4,containsValue()判断指定的map集合中是否包含指定的value值

Boolean b1 = map.containsValue("李氏");

System.out.println("指定集合map中是否包含value李氏  :"+b1);

//判断只当的集合是否为空

Boolean b2 = map.isEmpty();

6-4,remove()移除指定集合中的key值

String value1= map.remove("a");

System.out.println("被移除的value是:"+value1);

判断a是否被移除

System.out.println("是否移除成功:"+map.containsKey("a"));返回的是map集合的长度

int len = map.size();

System.out.println("map集合的长度:"+len);

6-5,values()把map集合中的所有value的值转换成一个collection集合

Collection<String> co = map.values();

6-7,遍历map集合

步骤:

 * 1,把map中的所有的key放到一个集合中去

 * 2.遍历存放key集合的那个集合

 * 3.循环取出对应的key所对应的value集合

6-8,keySet()把所有的key转换成set集合

Set<String> set = map.keySet();

System.out.println(set);

//foreach遍历存放key的set集合

for(String str:set){

//获取对应的key所对应的value值

String value2 = map.get(str);

System.out.print(value2+"  ");

}

System.out.println();

//迭代器遍历存放key的set集合

set = map.keySet();

//把map集合中的key转换成迭代器

Iterator<String> ite = set.iterator();

//遍历迭代器

while(ite.hasNext()){//判断是否存在下一个key值

String key = ite.next();//取出下一个元素

//取出对应的key值的value值

String value3 = map.get(key);

//打印value的值

System.out.print(value3+" ");

}

打印:[d=王er, e=王san, b=李氏, c=王五]

Set s = map.entrySet();

System.out.println(s);

7,设置线程安全的集合synchronizedList

创建线程安全的ArrayList集合

ArrayList<String> list =(ArrayList<String>)Collections.synchronizedList(new ArrayList<String>());

//创建线程安全的Set集合

Set cost = Collections.synchronizedSet(new HashSet());

//创建线程安全的Map集合

Map<String, String> comap = Collections.synchronizedMap(new HashMap<String, String>());

}