Java：集合框架的工具类

集合框架的工具类

Arrays:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

Collections:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

包括：

1、asList将数组变成list集合：

static <T> List<T> asList(T... a)

返回一个受指定数组支持的固定大小的列表。

//例子1：

import java.util.*;

class ArraysTest

{

    public static void sop(Object obj)

    {

      System.out.println(obj);

    }

    public static void main(String[] args)

    {

      BasicTypetolist();

      ObjecttoList();

      tostring();

    }

    public static void tostring()

    {

       String[] str = {"aaa","bc","kkkk","qq"};

       //字符串形式返回数组内容

       sop(Arrays.toString(str));

    }

    public static void BasicTypetolist()

    {

       int[] nums = {4,8,9,10};

       List<int[]> list = Arrays.asList(nums);

       sop(list);

       /*

        数组中的元素如果是对象，那么数组变成集合后，数组中的元素就直接变为集合中的元素存在；

        数组中的元素如果是基本数据类型，那么数组变成集合后，数组就直接变为集合中的元素存在；

       */

       //Integer[] inte = {4,8,9,10};

       //List<Integer> list = Arrays.asList(inte);

       //sop(list);

    }

    public static void ObjecttoList()

    {

       String[] str = {"aaa","bc","kkkk","qq"};

       //将字符数组转换为集合

       /*

         好处：可以使用集合中的思想来操作数组。

         注意：将数组变成集合，不可以使用集合的增删操作方法.因为数组的长度是固定的。

               如果进行增删操作，就会产生不支持操作异常...

       */

       List<String> list =  Arrays.asList(str);

       sop("contains:"+list.contains("qq"));

      // sop(list.add("zz"));//UnsupportedOperationException

       sop(list);

    }

}

2、二分方查找：

基本数据类型：byte、short、int、double、float、long、char

static int binarySearch(基本数据类型[] a, 基本数据类型 key)

使用二分搜索法来搜索指定的基本数据类型数组类型数组，以获得指定的值。

static int binarySearch(基本数据类型[] a, int fromIndex, int toIndex, 基本数据类型 key)

使用二分搜索法来搜索指定的基本数据类型数组类型数组的范围，以获得指定的值。

static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)

使用二分搜索法来搜索指定数组的范围，以获得指定对象。

static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)

使用二分搜索法来搜索指定数组的范围，以获得指定对象。

static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)

使用二分搜索法来搜索指定数组，以获得指定对象。

//例子2：

import java.util.*;

class CollectionsbinarySearch

{

    public static void main(String[] args)

    {

       binarySearchdemo1();

       binarySearchdemo2();

    }

    public static void binarySearchdemo1()

    {

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

       list.add("abcd");

       list.add("aaa");

       list.add("z");

       list.add("cdefg");

       list.add("kkkkkkk");

       list.add("qq");

       sop("list:"+list);

       Collections.sort(list);

       sop("list:"+list);

       //使用二分搜索法搜索指定列表，以获得指定对象。

       sop("index="+Collections.binarySearch(list,"z")+"\n");

    }

    public static void binarySearchdemo2()

    {

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

       list.add("abcd");

       list.add("aaa");

       list.add("z");

       list.add("cdefg");

       list.add("kkkkkkk");

       list.add("qq");

       sop("list:"+list);

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

       sop("list:"+list);

       //使用二分搜索法搜索指定列表，(按照比较器)以获得指定对象。

       sop("index="+Collections.binarySearch(list,"z",new Mycomparator()));

    }

    public static<T> void sop(T t)

    {

        System.out.println(t);

    }

}

class Mycomparator implements Comparator<String>  ////定义一个比较器

{

    public int compare(String str1,String str2)

    {

       int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));

       return num==0? str1.compareTo(str2):num;

    }

}

3、复制指定的数组：

基本数据类型：boolean、byte、short、int、double、float、long、char

static 基本数据类型[] copyOf(基本数据类型[] original, int newLength)

复制指定的数组，截取或用 0或false或null填充（如有必要），以使副本具有指定的长度。

static <T> T[] copyOf(T[] original, int newLength)

复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)

复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

4、将指定原数组范围复制到新数组：

基本数据类型：boolean、byte、short、int、double、float、long、char

static 基本数据类型[] copyOfRange(基本数据类型[] original, int from, int to)

将指定数组的指定范围复制到一个新数组。

static <T> T[] copyOfRange(T[] original, int from, int to)

将指定数组的指定范围复制到一个新数组。

static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)

将指定数组的指定范围复制到一个新数组。

5、比较两个数组中的内容是否相同。

基本数据类型：boolean、byte、short、int、double、float、long、char

static boolean equals(基本数据类型[] a, 基本数据类型[] a2)

如果两个指定的基本数据类型数组彼此相等，则返回 true。

static boolean deepEquals(Object[] a1, Object[] a2)

如果两个指定数组彼此是深层相等的，则返回 true。

6、返回数组的哈希值。

基本数据类型：boolean、byte、short、int、double、float、long、char

static int hashCode(基本数据类型[] a)

基于指定数组的内容返回哈希码。

static int deepHashCode(Object[] a)

基于指定数组的“深层内容”返回哈希码。

7、以字符串形式返回数组内容。

基本数据类型：boolean、byte、short、int、double、float、long、char

static String toString(基本数据类型[] a)

返回指定数组内容的字符串表示形式。

static String toString(Object[] a)

返回指定数组内容的字符串表示形式。

static String deepToString(Object[] a)

返回指定数组“深层内容”的字符串表示形式。

//例子7：

import java.util.*;

class CollectionToArray

{

    public static<T> void sop(T t)

    {

      System.out.println(t);

    }

    public static void main(String[] args)

    {

        colletiontoarray();

    }

    public static void colletiontoarray()

    {

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

      al.add("abc");

      al.add("bcd");

      al.add("kef");

      /*

      1、 指定类型的数组到底要多长呢？

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

          当指定类型的数组长度大于集合的Size，就不会再创建新数组。而是直接使用传递进来的数组。

          所以创建一个刚刚好的数组长度最好。即  集合.size()。

      2、 为什么要将集合变成数组呢？

          为了限制对集合中的元素进行操作。不需要再进行增删了。

      */

      String[] str1 = al.toArray(new String[0]);

      sop(Arrays.toString(str1));//结果是：[abc,bcd,kef]

      String[] str2 = al.toArray(new String[5]);

      sop(Arrays.toString(str2));//结果是：[abc,bcd,kef,null,null]

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

      sop(Arrays.toString(str3));//结果是：[abc,bcd,kef]

    }

}

8、用内容替换数组指定索引的内容、反转、替换、交换

基本数据类型：boolean、byte、short、int、double、float、long、char

static void fill(基本数据类型[] a, int fromIndex, int toIndex, 基本数据类型 val)

将指定的基本数据类型值分配给指定基本数据类型数组指定范围中的每个元素。

static void fill(基本数据类型[] a, 基本数据类型 val)

将指定的基本数据类型值分配给指定基本数据类型数组的每个元素。

static void fill(Object[] a, int fromIndex, int toIndex, Object val)

将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。

static void fill(Object[] a, Object val)

将指定的 Object 引用分配给指定 Object 数组的每个元素。

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

使用另一个值替换列表中出现的所有某一指定值。

static void reverse(List<?> list)

反转指定列表中元素的顺序。

static void swap(List<?> list, int i, int j)

在指定列表的指定位置处交换元素。

//例子8：

import java.util.*;

class CollectionsFillReverseReplace

{

    public static void sop(Object obj)

    {

       System.out.println(obj);

    }

    public static void main(String[] args)

    {

        filldemo();

        replaceAlldemo();

        reversedemo();

    }

    public static void filldemo()

    {

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

        list.add("abcd");

        list.add("aaa");

        list.add("zz");

        list.add("kkkkk");

        sop("list:"+list);

       //使用指定元素替换指定列表中的所有元素。

       Collections.fill(list,"pp");

       sop("list:"+list+"\n");

    }

    public static void replaceAlldemo()

    {

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

        list.add("abcd");

        list.add("aaa");

        list.add("zz");

        list.add("zz");

        list.add("kkkkk");

        sop("list:"+list);

      //使用另一个值替换列表中出现的所有某一指定值。

        sop(Collections.replaceAll(list,"zz","yy"));

        sop("list:"+list+"\n");

    }

    public static void reversedemo()

    {

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

       list.add("abcd");

       list.add("aaa");

       list.add("zz");

       list.add("kkkkk");

       sop("list:"+list);

       //反转指定列表中元素的顺序。

       Collections.reverse(list);

       sop("list:"+list);

    }

    public static void swapdemo()

    {

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

       list.add("abcd");

       list.add("aaa");

       list.add("zz");

       list.add("kkkkk");

       sop("list:"+list);

       //在指定列表的指定位置处(0和3位置处元素交换)交换元素。

       Collections.swap(list,0,3);

       sop("list:"+list);

    }

}

9、排序：

基本数据类型：byte、short、int、double、float、long、char

static void sort(Object[] a)

根据元素的自然顺序对指定对象数组按升序进行排序。

static void sort(Object[] a, int fromIndex, int toIndex)

根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。

static void sort(基本数据类型[] a)

对指定的基本数据类型数组按数字升序进行排序。

static void sort(基本数据类型[] a, int fromIndex, int toIndex)

对指定基本数据类型数组的指定范围按数字升序进行排序。

static <T> void sort(T[] a, Comparator<? super T> c)

根据指定比较器产生的顺序对指定对象数组进行排序。

static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)

根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。

//例子9

import java.util.*;

class CollectionsSort

{

    public static void main(String[] args)

    {

        sortdemo();

    }

    public static void sortdemo()

    {

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

       list.add("abcd");

       list.add("aaa");

       list.add("z");

       list.add("cdefg");

       list.add("kkkkkkk");

       list.add("qq");

       list.add("qq");

       sop(list); //排序前

       Collections.sort(list);

       sop(list); //排序后

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

       sop(list); //传入比较器排序后

    }

    public static<T> void sop(T t)

    {

        System.out.println(t);

    }

}

class Mycomparator implements Comparator<String>   //定义一个比较器

{

    public int compare(String str1,String str2)

    {

       int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));

       return num==0? str1.compareTo(str2):num;

    }

}

/*

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

 list.add(new Student());

class Student

{

}

public static<T extends Comparable <? super T>> void sort(List<Student> list) //接受的对象泛型T必须具备比较性，所以

{                                                                             //可以继承Comparable，

}

*/

10.逆转比较器：

static <T> Comparator<T> reverseOrder()

返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

返回一个比较器，它强行逆转指定比较器的顺序。

//例子10：

import java.util.*;

class ReverseOrder

{

    public static void sop(Object obj)

    {

       System.out.println(obj);

    }

    public static void main(String[] args)

    {

        Set<String> ts1 = new TreeSet<String>();

        ts1.add("abcde");

        ts1.add("aaa");

        ts1.add("k");

        ts1.add("cc");

        sop("自然顺序排序：");

        Iterator<String> it1 = ts1.iterator();

        while(it1.hasNext())

        {

          String str = it1.next();

          sop(str);

        }

       reverseorderdemo1();

       Set<String> ts2 = new TreeSet<String>(new Mycomparator());

        ts2.add("abcde");

        ts2.add("aaa");

        ts2.add("k");

        ts2.add("cc");

        sop("自定义字符串长度顺序排序：");

        Iterator<String> it2 = ts2.iterator();

        while(it2.hasNext())

        {

          String str = it2.next();

          sop(str);

        }

       reverseorderdemo2();

    }

    public static void reverseorderdemo1()

    {

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

        ts.add("abcde");

        ts.add("aaa");

        ts.add("k");

        ts.add("cc");

        //返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

        //Comparator co = Collections.reverseOrder();

        sop("返回比较器后，逆转自然顺序排序：");

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

        while(it.hasNext())

        {

          String str = it.next();

          sop(str);

        }

    }

    public static void reverseorderdemo2()

    {

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

        ts.add("abcde");

        ts.add("aaa");

        ts.add("k");

        ts.add("cc");

        //返回一个比较器，它强行逆转指定比较器的顺序（假如之前自定义设定的按照字符串长度）。

        //Comparator co = Collections.reverseOrder(new Mycomparator());

        sop("返回比较器后，逆转自定义字符串长度顺序排序：");

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

        while(it.hasNext())

        {

          String str = it.next();

          sop(str);

        }

    }

}

class Mycomparator implements Comparator<String>  ////定义一个比较器

{

    public int compare(String str1,String str2)

    {

       int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));

       return num==0? str1.compareTo(str2):num;

    }

}

11、Collections:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

例如(求集合元素最值)：

static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

根据元素的自然顺序，返回给定 collection 的最大元素。

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最大元素。

static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

根据元素的自然顺序返回给定 collection 的最小元素。

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最小元素

//例子11：

import java.util.*;

class CollectionsMaxMin

{

    public static void main(String[] args)

    {

        maxdemo();

        mindemo();

    }

    public static void maxdemo()

    {

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

       list.add("abcd");

       list.add("aaa");

       list.add("z");

       list.add("cdefg");

       list.add("kkkkkkk");

       list.add("qq");

       list.add("qq");

       sop("list:"+list);

       Collections.sort(list);

       sop(list);

       //根据元素的自然顺序，返回给定ArrayList集合中的最大元素

       String s1 = Collections.max(list);

       sop("max1="+s1);

       //根据指定比较器产生的顺序，返回给定ArrayList的最大元素（返回最长的字符串）。

       String s2 = Collections.max(list,new Mycomparator());

       sop("max2="+s2);

    }

    public static void mindemo()

    {

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

       list.add("abcd");

       list.add("aaa");

       list.add("z");

       list.add("cdefg");

       list.add("kkkkkkk");

       list.add("qq");

       list.add("qq");

       sop("list:"+list);

       Collections.sort(list);

       sop(list);

       //根据元素的自然顺序，返回给定ArrayList集合中的最小元素

       String s1 = Collections.min(list);

       sop("min1="+s1);

       //根据指定比较器产生的顺序，返回给定ArrayList的最小元素（返回最短的字符串）。

       String s2 = Collections.min(list,new Mycomparator());

       sop("min2="+s2);

    }

    public static<T> void sop(T t)

    {

        System.out.println(t);

    }

}

class Mycomparator implements Comparator<String>  ////定义一个比较器

{

    public int compare(String str1,String str2)

    {

       int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));

       return num==0? str1.compareTo(str2):num;

    }

}

12、Collections:里面都是静态方法，直接用来对各种集合进行操作的公有方法。

例如(集合加锁，让线程同步、随机排序)：

static <T> Collection<T> synchronizedCollection(Collection<T> c)

返回指定 collection 支持的同步（线程安全的）collection。

static <T> List<T> synchronizedList(List<T> list)

返回指定列表支持的同步（线程安全的）列表。

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

返回由指定映射支持的同步（线程安全的）映射。

static <T> Set<T> synchronizedSet(Set<T> s)

返回指定 set 支持的同步（线程安全的）set。

static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)

返回指定有序映射支持的同步（线程安全的）有序映射。

static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)

返回指定有序 set 支持的同步（线程安全的）有序 set。

static void shuffle(List<?> list)

使用默认随机源对指定列表进行置换。

static void shuffle(List<?> list, Random rnd)

使用指定的随机源对指定列表进行置换。

//例子12：

import java.util.*;

class CollectionsSynchronizedShuffle

{

    public static<T> void sop(T t)

    {

       System.out.println(t);

    }

    public static void main(String[] args)

    {

      shuffledemo();

    }

    public static void shuffledemo()

    {

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

       list.add("abcd");

       list.add("aaa");

       list.add("zz");

       list.add("kkkkk");

       sop("list:"+list);

       //使用默认随机源对指定列表进行置.（每一次运行结果可能都不一样）

       Collections.shuffle(list);

       sop("list:"+list+"\n");

    }

}

Java：集合框架的工具类的更多相关文章

【JAVA集合框架之工具类】
一.概述 JAVA集合框架中有两个很重要的工具类,一个是Collections,另一个是Arrays.分别封装了对集合的操作方法和对数组的操作方法,这些操作方法使得程序员的开发更加高效. public ...
Java最重要的21个技术点和知识点之JAVA集合框架、异常类、IO
(三)Java最重要的21个技术点和知识点之JAVA集合框架.异常类.IO 写这篇文章的目的是想总结一下自己这么多年JAVA培训的一些心得体会,主要是和一些java基础知识点相关的,所以也希望能分享 ...
Java集合框架（常用类） JCF
Java集合框架(常用类) JCF 为了实现某一目的或功能而预先设计好一系列封装好的具有继承关系或实现关系类的接口: 集合的由来: 特点:元素类型可以不同,集合长度可变,空间不固定: 管理集合类和接口 ...
Java 集合框架工具类
Collections Arrays Collections 集合框架的工具类, 里面的方法都是静态的, 可以直接使用类名调用常用方法 1. sort(List<T> list); // ...
Java集合框架(四)
Collections 集合框架的工具类着重讲解以下方法: 1.sort(): 1º根据元素的自然顺序对指定列表按升序进行排序,列表中的所有元素都必须实现comparable接口. pu ...
Java集合框架体系详细梳理，含面试知识点。
一.集合类集合的由来: 面向对象语言对事物都是以对象的形式来体现,为了方便对多个对象的操作,就需要将对象进行存储,集合就是存储对象最常用的一种方式. 集合特点: 1,用于存储对象的容器.(容器本身就 ...
集合中的工具类Collections和Arrays
集合框架的工具类: Collections: 方法sort(): List<String> list = new ArrayList<String>(); lis ...
12：集合map、工具类
一.map集合 Map:一次添加一对元素.Collection 一次添加一个元素. Map也称为双列集合,Collection集合称为单列集合. 其实map集合中存储的就是键值对(结婚证书), map ...
java集合框架——工具类
一.概述 JAVA集合框架中有两个很重要的工具类,一个是Collections,另一个是Arrays.分别封装了对集合的操作方法和对数组的操作方法,这些操作方法使得程序员的开发更加高效. public ...

随机推荐

USB硬件远程共享解决iphone已停用
悲剧的在iphone拆过电池之后,再开机显示iphone已停用,请在23000000分钟后再试一次算算这得45年了,可以留给孙子用了... 网上除了刷机和有同步过的电脑貌似没有别的办法了因是旧系统 ...
Bootstrap入门三：页面排版
在Bootstrap中,页面的排版都是从全局的概念上出发,定制了主体文本.强调文本.标题.Code风格.按钮.表单.表格等格式,并运用CSS3的@font-face和伪元素一起实现了一套icon主题. ...
Careercup - Google面试题 - 6407924087783424
2014-05-07 15:17 题目链接原题: Given an array of n elements (a1,a2,..ai,...,an). You are allow to chose a ...
使用IntersectionObserver更高效的监视某个页面元素是否进入了可见窗口
比如说,你想跟踪 DOM 树里的一个元素,当它进入可见窗口时得到通知. 也许想实现即时延迟加载图片功能,或者你需要知道用户是否真的在看一个广告 banner. 你可以通过绑定 scroll 事件或者用 ...
Load hlsl
这个函数和sample差不多不过没有samplestate和filter http://msdn.microsoft.com/zh-cn/library/windows/desktop/bb5096 ...
VS Bug 当获取其他项目的代码时, F5 无法进入调试模式. 也不报错....
在64位的机子下, 被获用的项目使用X86时会出现. 就会出现 F5 无法进入调试模式. 也不报错.... 打断点也没有用. 在不加入X86项目的代码时, 又可以运行.. 解决方案: 检查 ...
html之colspan && rowspan讲解
1.colspan && rowspan均在td标签中使用 2.每个单元格大小一致的前提 <table border="1" bordercolor=&quo ...
ASP.Net 上传进度条的实现方法
对于加载时间比较长的ASP.NET页面,我们可以在客户端浏览器中显示进度条来显示页面正在装载.下面就是具体的实现过程: 新建项目,名字为WebPortal,在项目类型中选择Visual C#项目或者V ...
ZOJ3784 String of Infinity(AC自动机&&强连通分量)
题意:给你n个禁止串,然后你只能用字符表的前m个字符去写一个无限长的串,要求是不能包含禁止串,而且串在后面不能出现循环比赛的时候想的是先建一个自动机,然后将自动机确定化,不能到达的状态全部弄出来.但 ...
POJ 3255
Roadblocks Time Limit: 2000MS Memory Limit: 65536K Total Submissions: 6605 Accepted: 2458 Descri ...

Java：集合框架的工具类

Java：集合框架的工具类的更多相关文章

随机推荐

热门专题