黑马程序员--Java基础之集合框架工具类

Java学习第17天，今天主要学习了集合工具类Collections和Arrays的用法。

import java.util.*;

/*

集合框架的工具类

Collections:使用Collection.sort()方法对数据元素进行排序

*/

/*

class CollectionsDemo

{

public static void main(String[] args)

{

List<String> list = new ArrayList<String>();

list.add("c");

list.add("abc");

list.add("sd");

list.add("gfooh");

list.add("nhdc");

sop(list);

Collections.sort(list); //该方法用于对元素的自然排序

//结果是: abc,c,gfooh,nhdc,sd

//想让元素按照字符串长度排序的可以使用对象比较器的方式；

sop(list);

}

public static void sop(Object obj)

{

System.out.println(obj);

}

}

*/

class CollectionsDemo

{

public static void sop(Object obj)

{

System.out.println(obj);

}

public static void main(String[] args)

{

// sortDemo();

//maxDemo();

//binarySearchDemo();

shuffleDemo();

}

public static void shuffleDemo()

{

List<String> list = new ArrayList<String>();

list.add("c");

list.add("abc");

list.add("sd");

list.add("gfooh");

list.add("ef");

list.add("nhdc");

sop(list);

Collections.shuffle(list); //对元素重新随机排序，，扑克牌 ，洗牌使用

sop(list);

}

//因为是ArrayList()集合，是有序的，使用binarySearch()方法找到元素对应的索引值

public static void binarySearchDemo()

{

List<String> list = new ArrayList<String>();

list.add("c");

list.add("abc");

list.add("sd");

list.add("gfooh");

list.add("ef");

list.add("nhdc");

Collections.sort(list);

sop(list);

//int index = Collections.binarySearch(list,"sd");//结果为5

int index = Collections.binarySearch(list,"sd");

//结果为-6，（怎么来的呢 -搜索位子-1/ -6 = -5-1）

sop(index);

}

//函数功能，取得元素自然排序中的最大值，max

public static void maxDemo()

{

List<String> list = new ArrayList<String>();

list.add("c");

list.add("abc");

list.add("sd");

list.add("gfooh");

list.add("ef");

list.add("nhdc");

Collections.sort(list);

sop(list);

//String max = Collections.max(list);//取得元素自然排序中的最大值

//取得元素最大长度的值

String max = Collections.max(list,new StrLenComparator());

sop("max="+max);

}

public static void sortDemo()

{

List<String> list = new ArrayList<String>();

list.add("c");

list.add("abc");

list.add("sd");

list.add("gfooh");

list.add("ef");

list.add("nhdc");

sop(list);

Collections.sort(list,new StrLenComparator());

//使用对象比较器的方式让元素按照字符串长度排序；

sop(list);

}

}

//定义对象比较器，实现功能：按照元素长度排序

class StrLenComparator implements Comparator<String>

{

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); //当长度相同时，按照自然排序

}

}

import java.util.*;

/*

将list集合中部分元素替换成指定元素

涉及到三个值（List, start, end）

*/

class CollectionsDemo2

{

public static void sop(Object obj)

{

System.out.println(obj);

}

public static void main(String[] args)

{

fillDemo();

}

//使用 Collections.fill();将集合中的元素全部替换

public static void fillDemo()

{

List<String> list = new ArrayList<String>();

list.add("c");

list.add("abc");

list.add("gfooh");

list.add("ef");

list.add("nhdc");

sop(list);

//Collections.fill(list,"kk");

//将 abc 替换成 kkk

Collections.replaceAll(list,"abc","kkk");

sop(list);

//反转元素

Collections.reverse(list);

sop(list);

}

}

import java.util.*;

/*

*/

class CollectionsDemo3

{

public static void sop(Object obj)

{

System.out.println(obj);

}

public static void main(String[] args)

{

orderDemo();

}

//使用 Collections.fill();将集合中的元素全部替换

public static void orderDemo()

{

//TreeSet<String> ts = new TreeSet<String>();

//按照字符串长度排序（有短到长）

//TreeSet<String> ts = new TreeSet<String>(new StrLenComparator());

//按照字符串有长到短排序

TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder( new StrLenComparator()));

ts.add("ab");

ts.add("a");

ts.add("gfooh");

ts.add("efk");

ts.add("nhdc");

sop(ts);

Iterator it = ts.iterator();

while (it.hasNext())

{

sop(it.next());

}

}

}

class StrLenComparator implements Comparator<String>

{

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); //当长度相同时，按照自然排序

}

}

import java.util.*;

/*

将集合变成数组

Collection 接口中的 toArray 方法

*/

class CollectionToArray

{

public static void sop(Object obj)

{

System.out.println(obj);

}

public static void main(String[] args)

{

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

al.add("abc1");

al.add("abc3");

al.add("abc2");

/*

1,指定类型的数组到底要定义多长呢？al.toArray(new String[长度]);

当指定类型的数组长度小于集合的size，（al.toArray(new String[1]);）那么该方法内部会创建一个新的数组，长度为集合的size

当指定类型的数组长度大于了集合的size，（al.toArray(new String[5]);）就不会创建新数组，而是使用传递进来的数组

所以创建一个刚刚好的数组最优 al.toArray(new String[al.size()]);

2,为什么要将集合边数组？

为了限定对元素的操作，不需要进行增删

*/

sop(al);

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

sop(Arrays.toString(arr)); //将数组arr[]变成集合才能打印

}

}

import java.util.*;

/*

Arrays:用于操作数组的工具类，

里面全是静态方法

asList: 将数组变成List集合

*/

class ArraysDemo

{

public static void sop(Object obj)

{

System.out.println(obj);

}

public static void main(String[] args)

{

//将整型数组变成字符串

//int[] arr = {4,58,6};

//String s = Arrays.toString(arr);

//sop(s);

//将字符串数组变成List集合

String[] arr ={"aa","abc","kk"};

//List<String> li = Arrays.asList(arr);

/*

把数组变成List集合的好处

1，可是使用集合的思想和方法来操作数组中的元素

注意：

将数组变成集合，不可以使用集合的增删方法

因为数组的长度是固定的

可以使用方法有 contain() get() indexOf() subList()

如果增删了，会出现 UnsupportedOperationException

*/

//sop("contains: "+li.contains("aa"));

//li.add("qqq"); //出现异常UnsupportedOperationException

//int[] nums = {4,58,6};

Integer[] nums = {4,58,6};

List<Integer> li = Arrays.asList(nums);

/*

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

如果数组中的元素都是基本数据类型，那么会将该数组作为结合中的元素存在

*/

sop(li);

}

}

import java.util.*;

/*

高级for

格式：

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

{

}

对集合进行遍历。

只能获取集合元素，但不能对集合进行操作，

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

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

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

高级for有一个局限性，必须有别遍历的目标

建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义角标

*/

class ForEachDemo

{

public static void sop(Object obj)

{

System.out.println(obj);

}

public static void main(String[] args)

{

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

al.add("abc1");

al.add("abc3");

al.add("abc2");

//JDK 1.5

for(String s : al)

{

sop(s);

}

/* jdk 1.2-1.4

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

while (it.hasNext())

{

sop(it.next());

}

*/

HashMap<Integer,String> hm = new HashMap<Integer,String>();

hm.put(1,"a");

hm.put(3,"c");

hm.put(2,"b");

Set<Integer> keySet = hm.keySet();

for(Integer i : keySet)

{

sop(i+"..."+hm.get(i));

}

//Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();

//Map.Entry<Integer,String> me = entrySet.

for(Map.Entry<Integer,String> me : hm.entrySet() )

{

sop(me.getKey()+"......"+me.getValue());

}

}

}

/*

JDK 1.5 版本出现的新特性

方法的可变参数：

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

*/

class ParamMethodDemo

{

public static void sop(Object obj)

{

System.out.println(obj);

}

public static void main(String[] args)

{

/*

int[] arr = {1,5,8,7,6,};

show(arr);

int[] arr2 ={5,9,63,52,0};

show(arr2);

*/

/*

可变参数：

其实就是上一种数组参数的简写形式，

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

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

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

*/

// show(5,8,6,11,5);

//show(5,8,66,4,"hhahha") 不行

show("hhahha",5,8,66,4); //行

}

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

{

sop(arr.length);

}

/* 方法操作的都是同一类型，可以考虑定义数组

public static void show(int a,int b)

{

}

public static void show(int a,int b,int c)

{

}

*/

/* 问题有来了，要调用方法，首先的定义数组，也很麻烦，

public static void show(int[] arr)

{

}

*/

}

/*

StaticImport: 静态导入

当类名重名时，需要指定具体的包名

当方法重名时，指定具体所属的对象或者类

packa/Demo.class

packb/Demo.class

import packa.*;

import packb.*;

*/

import java.util.*;

import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员

import static java.lang.System.*;

class StaticImport

{

public static void main(String[] args)

{

int[] arr ={12,9,11,7};

sort(arr); //对数组进行排序

int index = binarySearch(arr,7);

System.out.println("index="+index);

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

/* 每次输入态度代码，太麻烦，使用静态导入，简写

Arrays.sort(arr);

int index = Arrays.binarySearch(arr,6);

System.out.println("index="+index);

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

*/

}

}