java collections wiki_java集合框架工具类Collections,集合的操作

1

import java.util.*;public classasList

{public static voidmain(String args[])

{//int arr[] = {1,2,3,4,45};//List list = Arrays.asList(arr);//list.add("qq"); 这里不能添加,因为数组的长度是固定的//Integer[] nums = {2,4,5,2};//List li = Arrays.asList(nums);//如果数组中的元素是对象,那么变成集合时,数组中的元素就直接转成集合中的元素//如果数组中的元素是基本数据类型,那么会将该数组作为集合中的元素存在.

String arr[]= {"abc","cc","kkk"};

List list =Arrays.asList(arr);

list.contains("cc");

}public staticboolean myContains(String[] arr,String key)

{for(int x=0;x

{if(arr[x].equals(key))return true;

}return false;

}

}

数组变集合

import java.util.*;

public class asList

{

public static void main(String args[])

{

//int arr[] = {1,2,3,4,45};

//List list = Arrays.asList(arr);

//list.add("qq");这里不能添加,因为数组的长度是固定的

//Integer[] nums = {2,4,5,2};

//List li = Arrays.asList(nums);

//如果数组中的元素是对象,那么变成集合时,数组中的元素就直接转成集合中的元素

//如果数组中的元素是基本数据类型,那么会将该数组作为集合中的元素存在.

String arr[] = {"abc","cc","kkk"};

List list = Arrays.asList(arr);

list.contains("cc");

}

public static boolean myContains(String[] arr,String key)

{

for(int x=0;x

{

if(arr[x].equals(key))

return true;

}

return false;

}

}

package pack;

import java.util.*;

public class DemoTwo {

public static void main(String args[]) {

List list = new ArrayList();

list.add("abcd");

list.add("aaa");

list.add("zz");

list.add("kkk");

list.add("qq");

list.add("z");

/*

* Collections.sort(list); System.out.println(list);

*

* int a1 =Collections.binarySearch(list,"z"); //用binarySeratch都必须是有序的

*

* int a2 =Collections.binarySearch(list,"aaaa"); //这里返回-2 -(1) -1

* 返回它应该插入的地方 System.out.println(a2);

*

* int index = halfSearch(list,"cc"); //这个和binarySearch一样功能

* System.out.println(index);

*/

Collections.sort(list, new MyComparator()); // 这里

sop(list);

int index = halfSearch2(list, "aaa", new MyComparator());// 这里要和排序的方法一样

sop(index);

}

public static void sop(Object obj) {

System.out.println(obj);

}

public static int halfSearch1(List list, String key) // 这里是按照字母顺序排序

{

int max, min, mid;

max = list.size() - 1;

min = 0;

while (min <= max) {

mid = (max + min) >> 1; // /2

String str = list.get(mid);

int num = str.compareTo(key);

if (num > 0)

max = mid - 1;

else if (num < 0)

min = mid + 1;

else

return mid;

}

return min;

}

public static int halfSearch2(List list, String key,

Comparator cmp) { // 这里是按照字母长度排序

int max, min, mid;

max = list.size() - 1;

min = 0;

while (min <= max) {

mid = (max + min) >> 1; // /2

String str = list.get(mid);

int num = cmp.compare(str, key);

if (num > 0)

max = mid - 1;

else if (num < 0)

min = mid + 1;

else

return mid;

}

return min;

}

}

class MyComparator implements Comparator {

public int compare(String s1, String s2) {

if (s1.length() > s2.length())

return 1;

if (s1.length() < s2.length())

return -1;

return s1.compareTo(s2);

}

}

package pack;

import java.util.*;

public class DemoTwo

{

public static void main(String args[])

{

//TreeSet ts= new TreeSet(new MyComparator());

//TreeSet ts= new TreeSet(Collections.reverseOrder());

//将已知比较器顺序逆转

TreeSet ts= new TreeSet(Collections.reverseOrder(new MyComparator()));

ts.add("dsfdsf");

ts.add("fssd");

ts.add("wwsdf");

ts.add("ysfd");

ts.add("zdfdf");

System.out.println(ts);

}

}

class MyComparator implements Comparator

{

public int compare(String s1,String s2)

{

return s2.compareTo(s1);

}

}

集合变数组

package pack;

import java.util.*;

public class DemoTwo

{

public static void main(String args[])

{

/*

1当指定类型的数组到底要定义多长呢?

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组,长度为集合的size.

2,最好创建一个刚刚好的数组最好

*/

ArrayList al = new ArrayList();

al.add("abc1");

al.add("abc2");

al.add("abc3");

//String arr[] = al.toArray(new String[5]);//这里是创建数组的对象和大小和类型

String[] arr = al.toArray(new String[al.size()]);

System.out.println(Arrays.toString(arr));

}

}

// 为什么集合变数组 为了限定对元素的操作.

List list = new ArrayList();

Collections.replaceAll(list,"aaa","litiepeng");//替换list集合里面的元素替

Collections.reverse(list);//倒转

Collections.fill(list,"pp");//意思就是用东西替换集合里的所有元素

String max = Collections.max(list);//找出最大的来

String max = Collections.max(list,new MyComparator());//找出最长的来

Collections.sort(list);//排序

Collections.sort(list,new MyComparator());//按照自己的构造器排序

Collections.binarySearch(list,key);

Collections.binarySearch(list,key,new mycomparator());

Collections.fill(List list,T obj);//把集合全部换成别的

Collections.max(Collection c)

Collections.max(Collection c,new myComparator())

同理min

Collections.mix(Collection c)

Collections.mix(Collection c,new myComparator())

Collections.replaceAll(list,orld,new)用新的换旧的

Collections.reverse(List list);

Collections.reverseOrder()//返回一个构造器

Collections.reverseOrder(new myComparator())

Collections.swap(List> list, int i, int j)

Collections.synchronizedList(list)

Collections.shuffle(List> list) 使用默认随机源对指定列表进行置换。 意思就是把集合里面的东西随机再次排列一遍

Arrays.asList(数组)//数组变集合

Arrays.binarySearch()

数组变集合时

//int arr[] = {1,2,3,4,45};

//List list = Arrays.asList(arr);

//list.add("qq");这里不能添加,因为数组的长度是固定的

//Integer[] nums = {2,4,5,2};

//List li = Arrays.asList(nums);

//如果数组中的元素是对象,那么变成集合时,数组中的元素就直接转成集合中的元素

//如果数组中的元素是基本数据类型,那么会将该数组作为集合中的元素存在.

集合变数组

//String arr[] = al.toArray(new String[5]);//这里是创建数组的对象和大小和类型

String[] arr = al.toArray(new String[al.size()]);

/*

1当指定类型的数组到底要定义多长呢?

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组,长度为集合的size.

2,最好创建一个刚刚好的数组最好

*/

/* 为什么集合变数组

为了限定对元素的操作.

String[] arr = {"abc","cc","kkkk"};

List list = Arrays.asList(arr);

list.contains("cc");

list.add("qq");//异常 UnsupportedOperationException,因为数组的长度是固定.

注意:将数组变成集合,不可以使用集合的增删方法.

其他的都可以用

contains.get.indexOf(),subList()

如果你增删,会发生异常

把数组变成list集合后有什么好处?

答:当要判断数组中是否存在某个元素.可以把数组变成list

可以使用集合的思想和方法来操作数组中的元素.

高级for循环

格式:

for(数组类型 变量名:被遍历的集合(Collection)或者数组)

{

}

对集合进行遍历.

只能获取集合元素,但是不能对集合进行操作.

迭代器除了遍历,还可以进行remove集合中元素的动作.

如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作.

传统for和高级for有什么区别呢?

高级for有一个局限性,必须有被遍历的目标.

可变参数:

在使用时注意:可变参数一定要定义在参数列表的最后面

可变参数:其实就是上一种数组参数的简写形式.

不用每一次都手动的建立数组对象.

只要将要操作的元素作为参数传递即可

隐式将这些参数封装成了数组

public static void show(String str,int... arr)