Java基础详解之集合框架工具Collections

一、collections

说明：collcetions是集合框架中的工具，特点是方法都是静态的。

二、collections中的常见方法

1，对list进行二分查找：前提该集合一定要有序。
			int binarysearch(list,key);//要求list集合中的元素都是comparable的子类。
			int binarysearch(list,key,comparator);
		2，对list集合进行排序。
			sort(list);
			sort(list,comaprator);
		3，对集合取最大值或者最小值。
			max(collection)
			max(collection,comparator)
			min(collection)
			min(collection,comparator)
		4，对list集合进行反转。
			reverse(list);
		5，对比较方式进行强行逆转。
			comparator reverseorder();
			comparator reverseorder(comparator);
		6，对list集合中的元素进行位置的置换。
			swap(list,x,y);
		7，对list集合进行元素的替换。如果被替换的元素不存在，那么原集合不变。
			replaceall(list,old,new);

三、aarrays：用于对数组操作的工具类

1，binarysearch(int[])
		   binarysearch(double[])...
		2，sort(int[])
		   sort(char[])....
		3，tostring(int[]).....:将数组变成字符串。
		4，copyof();复制数组。
		5，copyofrange():复制部分数组。
		6，equals(int[],int[]);比较两个数组是否相同。
		
		7，list aslist(t[]);将数组变成集合。
			这样可以通过集合的操作来操作数组中元素，
			但是不可以使用增删方法，add，remove。因为数组长度是固定的，会出现unsupportoperationexcetion。
			可以使用的方法：contains，indexof。。。
			如果数组中存入的基本数据类型，那么aslist会将数组实体作为集合中的元素。
			如果数组中的存入的应用数据类型，那么aslist会将数组中的元素作为集合中的元素。

		
		如果想要将集合变数组：
		可以使用collection中的toarray方法。
		传入指定的类型数组即可，该数组的长度最好为集合的size。

四、二分查找过程中的默认比较器

// 在二分查找中设定默认的比较器
import java.util.arraylist;
import java.util.collections;
import java.util.comparator;
import java.util.list;

public class binaryserach {

    public static void main(string[] args)
    {
        sortdemo();
    }

    public static void sortdemo()
    {
        list<string> list = new arraylist<string>(); // list集合没有比较方法
        list.add("abcd");
        list.add("aaa");
        list.add("bbb");
        list.add("abcdcdc");
        list.add("z");
        list.add("zz");
        list.add("qq");

        sop("原集合为："+list);
        int index = collections.binarysearch(list,"bbb",new strlencomparator2());
        sop("自定义比较器的index: "+index);
        int index2 = collections.binarysearch(list,"abcd");
        sop("不传入比较器index："+index2);

    }
    public static void sop(object obj)
    {
        system.out.println(obj);
    }
}

class strlencomparator2 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.lang.reflect.array;
import java.util.arraylist;
import java.util.arrays;

public class collectiontoarray {
    public static void main(string[] args)
    {
        arraylist<string> al = new arraylist<string>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        al.add("abc4");
        al.add("abc5");

        system.out.println(al);

        string[] arr = al.toarray(new string[al.size()]);  // toarray 方法把集合转换为数组
        system.out.println(arrays.tostring(arr));//打印内容
    }
}

六、增强for循环

// 增强for循环的出现是为了解决总是使用迭代器方法进行元素提取

import java.util.arraylist;
import java.util.hashmap;
import java.util.map;
import java.util.set;

public class foreachdemo {
    public static void main(string[] args)
    {
        // 例子一：
        arraylist<string> al = new arraylist<string>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        al.add("abc4");

        for(string s : al)
        {
            system.out.println(s);
        }
        //system.out.println(al);

        // 例子二：hashmap的增强for循环，使用entryset()
        system.out.println("例子二：hashmap的增强for循环,使用entryset()");
        hashmap<integer,string> hm = new hashmap<integer, string>();
        hm.put(1,"wzy1");
        hm.put(2,"wzy2");
        hm.put(3,"wzy3");
        hm.put(4,"wzy4");

        for (map.entry<integer,string> it : hm.entryset())
        {
            system.out.println("key: "+it.getkey()+"--- value："+it.getvalue());
        }

        // 例子三：hashmap的增强for循环，使用keyset()
        system.out.println("例子三：hashmap的增强for循环,使用keyset()");
        set<integer> keyset = hm.keyset();
        for(integer i : keyset)
        {
            system.out.println("key: "+i+"--- value："+hm.get(i));
        }
    }
}

七、关于可变参数的方法

一般的，在java中使用重载的方法应对不同的数据对象，让它们都可以使用方法，但是还有一种写法，可以只写一个方法来接收数据，也不需要建立新的对象。

// 例子一：
public class mutilmethod {
    public static void main(string[] args)
    {
        show(1,2,3,4,5);

    }
    public static void show(int...a) // 可变参数写法，数组的特殊值放在开头
    {
        system.out.println(a.length);
    }
}



//例子二：数组有特殊的
public class mutilmethod {
    public static void main(string[] args)
    {
        show("字符串",2,3,4,5); // 特殊字符string与int发生组合

    }
    public static void show(string c, int...a) // 可变参数写法，数组的特殊值放在开头
    {
        system.out.println(a.length);
    }
}

八、关于reverseorder函数使用

（1）collections提供的比较器作为新比较器
（2）强行逆转现有比较器

import java.util.*;

public class reverseorder {
    public static void main(string[] args)
    {
        sortdemo();
    }

    public static void sortdemo()
    {
        treeset<string> ts = new treeset<string>(collections.reverseorder()); // 传入reverseorder()将集合倒序排列
        ts.add("aaa");// 或者手写一个自定义比较器，之后使用reverseorder()函数强行逆转
        ts.add("abc");
        ts.add("a");
        ts.add("aa");
        ts.add("bbb");
        ts.add("cccc");
        ts.add("ddddd");
        ts.add("eeeeee");

        iterator it = ts.iterator();
        while (it.hasnext())
        {
            sop(it.next());
        }
    }
    public static void sop(object obj)
    {
        system.out.println(obj);
    }

九、静态类导入

import java.util.*;
import static java.util.arrays.*;
import static java.lang.system.*;

public class staticimport extends object {

    public static void main(string[] args)
    {
        int[] arr = {3,1,5};
        sort(arr); // 去掉了arrays.
        int index = binarysearch(arr,1);// 去掉了arrays.
        system.out.println(arrays.tostring(arr)); // 不能去掉arrays.
        out.println("index = "+index);// 去掉system.
    }
}

到此这篇关于java基础详解之集合框架工具collections的文章就介绍到这了,更多相关java集合框架工具collections内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！