java--------学习之《集合框架的工具类的应用》

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

Collections

      Collections.sort();//对集合中的元素进行自然顺序进行排序。

      Collections.max();//获取元素中的最大元素。

     Collections.binarySearch();//获取集合中某个元素的角标位置。

代码演示：

import java.util.*;

class Lianxi
{
    public static void main(String[] args)
    {
        maxDemo();
        binarySearchDemo();
        sortDemo();
    }
    //获取集合中的最大元素
    public static void maxDemo()
    {
        List<String>list= new ArrayList<String>();
       
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        sop(list);
        Collections.sort(list);
        sop(list);
        String max = Collections.max(list/*,newStrLenComparator()*/);
        sop("max:"+max);
    }
    //获取集合中某个元素的角标
    public static void binarySearchDemo()
    {
        List<String>list= new ArrayList<String>();
       
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        Collections.sort(list);
        sop(list);
        int index = Collections.binarySearch(list,"aaa");
        sop("index:"+index);
    }
    //对集合中的元素进行自然顺序的排序
    public static void sortDemo()
    {
        List<String>list= new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("z");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
       
        sop(list);
       
        //Collections.sort(list);
        Collections.sort(list, new StrLenComparator());
       
        sop(list);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
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);
       
    }
}
 

 

Collections.fill()方法：

       可以将list集合中的所有元素替换成指定元素

Collections.replaceAll()方法：

       可以指定某个集合中的某个元素将其替换成自定义的某个元素。

Collections.reverse();方法：

       将指定的集合里面的元素顺序对其反转。

代码演示：

import java.util.*;

class Lianxi
{
    public static void main(String[] args)
    {
        List<String>list= new ArrayList<String>();
       
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");
        sop(list);//输出结果为：[abcd, aaa, zz, kkkkk]
        //将集合中的所有元素全部都替换成，某个指定的元素。
        //Collections.fill(list, "pp");
        //sop(list);//输出结果为：[pp, pp, pp, pp]
        Collections.replaceAll(list,"aaa","pp");
        sop(list);//输出结果为：[abcd, pp, zz, kkkkk]
        Collections.reverse(list);
        sop(list);//输出结果为：[kkkkk, zz, pp, abcd]
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
 

 

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

    里面都是静态方法。

asList：将数组变成list集合

代码演示：

import java.util.*;

class Lianxi
{
    public static void main(String[] args)
    {
        String[]arr = {"abc","cc","kkkk"};
       
        //把数组变成集合的好处是：           
        List<String>list= Arrays.asList(arr);
        //可以使用集合的思想更方便的操作数组中的元素。
        sop("contains:"+list.contains("cc"));
        //list.add("qq");//运行时报错：UnsupportedOperationException(不支持操作异常)
        //注意将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的
        sop(list);
       
        int[] nums = {2,4,5};
        List<int[]> li = Arrays.asList(nums);
        //如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素
        //如果数组中的元素都是基本数据类型，呢么会将该数组作为集合中的元素存在。
        sop(li);//输出结果是一个数组的哈希值。
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
 

 

集合变数组。

Collection接口中的toArray方法。

演示：

import java.util.*;

class Lianxi
{
    public static void main(String[] args)
    {
        ArrayList<String>al = new ArrayList<String>();
       
        al.add("abc1");
        al.add("abc3");
        al.add("abc2");
       
        //讲一个集合转变成一个String类型的数组。
        //String[] str = al.toArray(new String[0]/*数组长度定义为0*/);
        //注意：当指定类型的数组长度小于了集合的size。
        //那么该方法内部会创建一个新的数组，长度为集合的size
        //当指定类型数组的长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组
        //sop(Arrays.toString(str));//输出结果：[abc1, abc3, abc2]
                //但是这样做相对会耗费空间
        //解决办法：
        //所以创建一个刚刚好的数组长度为最优。
        String[]arr = al.toArray(new String[al.size()]);
        sop(Arrays.toString(arr));
        //为什么要将集合变成数组？
        //是为了限定对元素的操作。
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
 

 

高级for循环（JDK1.5出现的新特性）

格式：

for（数据类型 变量名 ：被遍历的集合（Collection）或者数组）

{

   

}

好处：简化代码的书写

弊端，局限性：用增强for循环对集合进行遍历时：

只能获取集合元素，但是不能对集合进行其它的操作。

 

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

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

 

代码演示：

class Lianxi
{
    public static void main(String[] args)
    {
        ArrayList<String>al = new ArrayList<String>();
       
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        //增强for的好处：简化了代码的书写，
        //局限性：只能对集合中的元素进行取出，而不能做修改动作。
        for(String s : al)
        {
            sop(s);
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
 

 

JDK1.5版本的新特性（可变参数）

 

方法的可变参数。

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

代码演示：

import java.util.*;

class Lianxi
{
    public static void main(String[] args)
    {
        //可变参数：不用手动建立数组对象，只要将要操作的元素作为参数传递即可。
        //隐式将这些参数封装成了数组。
        show("hehe",1,2,6,5,8,9);
        //
    }
                    //可变参数一定定义在参数列表的最后面
    public static void show(String s,int...arr)
    {
        sop(arr.length);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}