Java基础——Collections+Arrays工具类+可变参数+静态导入

最新推荐文章于 2024-05-24 09:21:57 发布

Y走路带风

最新推荐文章于 2024-05-24 09:21:57 发布

阅读量1k

点赞数

分类专栏： java笔记文章标签： Collections Arrays工具类可变参数静态导入

本文链接：https://blog.csdn.net/Mr_YangXianfa__/article/details/45628505

版权

java笔记专栏收录该内容

26 篇文章 0 订阅

订阅专栏

1. 集合工具类(Collections静态方法-sort,max,binaryseach,swap)

概述：

集合框架的工具类。

Collections:集合框架的工具类。里面定义的都是静态方法。

常见操作

1、查找

Tmax(Collection<? extends T> coll);//根据集合的自然顺序，获取coll集合中的最大元素

Tmax(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序，获取coll集合中的最大元素

intbinarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象

2、替换

voidfill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj

booleanreplaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值

void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素

3排序：

void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序

void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序

voidsort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序

4、反转

reverse(List<?> list);//反转list集合中元素的顺序

Comparator reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

ComparatorreverseOrder(Comparator<T> cmp);//返回一个比较器，强行逆转了指定比较器的顺序

5、同步的集合

List<T>synchronizedList(List<T> list);//返回支持的同步（线程安全的）List集合

Map<K,V>synchronizedList(Map<K,V> m);//返回支持的同步（线程安全的）Map集合

Collections和Collection有什么区别？

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

它有两个常用的子接口，

List：对元素都有定义索引。有序的。可以重复元素。

Set：不可以重复元素。无序。

Collections是集合框架中的一个工具类。该类中的方法都是静态的

提供的方法中有可以对list集合进行排序，二分查找等方法。

通常常用的集合都是线程不安全的。因为要提高效率。

如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

应用案例：

import java.util.*;

class  CollectionsDemo

{

         public static void main(String[] args) 

         {

                   sortDemo();

 

         }

 

         public static void binarySearchDemo()//使用二分搜索法查找指定列表，必须是有序集合，获得指定的对象

         {

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

 

                   list.add("abcd");

                   list.add("aaa");

                   list.add("zz");

                   list.add("kkkkk");

                   list.add("qq");

                   list.add("z");

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

 

                   sop(list);

 

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

                   //int index = halfSearch(list,"cc");

                   int index = halfSearch2(list,"aaaa",new StrLenComparator());

                   sop("index="+index);

         }

         //模拟binarysearch功能，折半法原理

         public static int halfSearch(List<String> 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-1;

         }

         //如果list集合的元素不具备比较性，则定义比较器

         public static int halfSearch2(List<String> list,String key,Comparator<String> 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-1;

         }

 

         public static void maxDemo()

         {

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

 

                   list.add("abcd");

                   list.add("aaa");

                   list.add("zz");

                   list.add("kkkkk");

                   list.add("qq");

                   list.add("z");

                   Collections.sort(list);

                   sop(list);

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

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

                   sop("max="+max);

         }

 

         public static void sortDemo()

         {

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

 

                   list.add("abcd");

                   list.add("aaa");

                   list.add("zz");

                   list.add("kkkkk");

                   list.add("qq");

                   list.add("z");

                   

                   sop(list);

 

                   //Collections.sort(list);//默认按照ASCII码排序，自然排序

                   Collections.sort(list,new StrLenComparator());//自定义排序方式，定义比较器

                   //Collections.swap(list,1,2);// 在指定列表的指定位置处交换元素。

                   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);

         }

}

/*

class Student

{

}

list.add(new Student());

 

public static <T extends Comparable<? super T>> void sort(List<T> list)//T元素必须具备比较性

，所以必须是compareable的子类

{

         

}

*/

2. Collections-替换+置换+反转+reverseOrder

import java.util.*;

 

class StrComparator implements Comparator<String>

{

         public int compare(String s1,String s2)

         {

                   /*//按照自然排序反转输出,return的值替换即可；

                   int num = s1.compareTo(s2);

                   if(num>0)

                            return -1;

                   if( num<0)

                            return 1;

                   return num;

                   */

                   //按照自然排序反转输出,s1与s2换位置即可；

                   return s2.compareTo(s1);

         }

}

 

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);

         }

}

class CollectionsDemo2 

{

         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");

                   list.add("qq");

                   list.add("z");

 

                   sop(list);

                   Collections.shuffle(list);// 使用默认随机源对指定列表进行置换。将集合随机重新排放

                   sop(list);

         }

         public static void orderDemo()

         {

                   TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new 

StrLenComparator()));//返回一个比较器，它强行逆转指定比较器的顺序。

 

                   ts.add("abcde");

                   ts.add("aaa");

                   ts.add("k");

                   ts.add("cc");

 

                   Iterator it = ts.iterator();

                   while(it.hasNext())

                   {

                            System.out.println(it.next());

                   }

         }

 

 

         public static void replaceAllDemo()

         {

 

 

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

 

                   list.add("abcd");

                   list.add("aaa");

                   list.add("zz");

                   list.add("kkkkk");

 

                   sop(list);

 

                   Collections.replaceAll(list,"aaa","pp");//按照元素替换，使用另一个值替换列表中出现的所有某一指定值。

 

                   sop(list);

                   Collections.reverse(list);//反转，原理就是交换位置，反转指定列表中元素的顺序。

 

                   sop(list);

         }

 

 

         /*

         练习。fill方法可以将list集合中所有元素替换成指定元素。

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

 

         */

         public static void fillDemo()

         {

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

 

                   list.add("abcd");

                   list.add("aaa");

                   list.add("zz");

                   list.add("kkkkk");

                   

                   sop(list);

                   Collections.fill(list,"pp");//使用指定元素替换指定列表中的所有元素。

                   sop(list);

 

         }

         public static void sop(Object obj)

         {

                   System.out.println(obj);

         }

}

3. Collections工具类为线程添加锁

synchronizedList(List<T> list):返回指定列表支持的同步（线程安全的）列表。

添加，删除操作不能同时进行，原理是他们用的是同一个锁；

synchronizedMap(Map<K,V> m)：返回由指定映射支持的同步（线程安全的）映射。

4. Arrays工具类:数组转集合

概述：

Arrays:用于操作数组的工具类。里面都是静态方法。

asList:将数组变成list集合

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

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

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

因为数组的长度是固定。

contains。

get

indexOf()

subList();

如果你增删。那么会发生UnsupportedOperationException,

请看如下实例：

import java.util.*;

class  test

{

    publicstaticvoid main(String[] args) 

    {

//     int[] arr = {2,4,5};

//

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

       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};

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

 

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

       /*

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

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

       */

       sop(li);

    }

    //判断某元素是否存在于数组中，此方法麻烦，所以将数组转换成集合，调用contains方法

    publicstaticboolean myContains(String[] arr,String key)

    {

       for(int x=0;x<arr.length; x++)

       {

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

              returntrue;

       }

       returnfalse;

    }

    

    publicstaticvoid sop(Object obj)

    {

       System.out.println(obj);

    }

 

}

5. Arrays工具类:集合转数组

集合变数组。

Collection接口中的toArray方法。

<T> T[]toArray(T[] a);将集合变为指定类型的数组。

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

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

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

所以创建一个刚刚好的数组最优。

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

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

如：

import java.util.*;

class  CollectionToArray

{

    publicstaticvoid main(String[] args) 

    {

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

 

       al.add("abc1");

       al.add("abc2");

       al.add("abc3");

 

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

 

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

 

    }

}

6. 增强for循环-高级for循环(foreach)

高级for循环

格式：

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

{

}

高级for循环对集合进行遍历。

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

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

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

凡是支持迭代器遍历的，就支持高级for循环，底层就是迭代器实现的；

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

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

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

如：

import java.util.*;

 

class ForEachDemo 

{

    publicstaticvoid main(String[] args) 

    {

 

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

 

       al.add("abc1");

       al.add("abc2");

       al.add("abc3");

 

 

       for(String s : al)

       {

           //s = "kk";

           System.out.println(s);

       }

 

       System.out.println(al);

       /*

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

 

       while(it.hasNext())

       {

           System.out.println(it.next());

       }

       */

 

       int[] arr = {3,5,1};

 

       for(int x=0; x<arr.length; x++)

       {

           System.out.println(arr[x]);

       }

       for(int i : arr)

       {

           System.out.println("i:"+i);

       }

 

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

 

       hm.put(1,"a");

       hm.put(2,"b");

       hm.put(3,"c");

 

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

       for(Integer i : keySet)

       {

           System.out.println(i+"::"+hm.get(i));

       }

 

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

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

 

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

       {

           System.out.println(me.getKey()+"------"+me.getValue());

       }

 

    }

}

7. 可变参数

JDK1.5版本出现的新特性。

方法的可变参数。

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

可变参数:其实就是上一种数组参数的简写形式。不用每一次都手动的建立数组对象。

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

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

请看示例：

class  ParamMethodDemo

{

    publicstaticvoid main(String[] args) 

    {

       //show(3,4);

       /*

       //虽然少定义了多个方法。

       但是每次都要定义一个数组。作为实际参数。

 

       int[] arr = {3,4};

       show(arr);

 

       int[] arr1 = {2,3,4,5};

       show(arr1);

       */

 

       show("haha",2,3,4,5,6);

       //show(2,3,4,5,6,4,2,35,9,"heh");

        //show();

 

    }

    publicstaticvoid show(String str,int... arr)//可变参数

    {

       System.out.println(arr.length);

    }

    /*

    public static void show(int[] arr)

    {

       

    }

    */

    /*

    public static  void show(int a,int b)

    {

       System.out.println(a+","+b);

    }

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

    {}

    */

}

8. 静态导入

JDK1.5版本新特性：

StaticImport 静态导入。

1、写法：

import staticjava.util.Arrays.*;//导入的是Arrays这个类中的所以静态成员。

没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。这样写在调用该类的静态方法时可以不用再写类名。如：Arrays.sort(数组);就可以直接写sort(数组);

2、注意：

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

当方法重名是，指定具备所属的对象或者类。

当导入的两个类中有同名成员时，需要在成员前加上相应的类名。

请看示例：

import java.util.*;

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

importstatic java.util.Collections.*;

/*

packa/Demo.class 

packb/Demo.class

 

import packa.*;

import packb.*;

*/

 

importstatic  java.lang.System.*;//导入了System类中所有静态成员。则打印语句也可简写

 

class  StaticImport //extends Object

{

    publicstaticvoid main(String[] args) 

    {

 

       out.println("haha");

       int[] arr = {3,1,5};

 

       sort(arr);

       int index = binarySearch(arr,1);

       out.println(Arrays.toString(arr));//这里的Arrays不能省略，因为此处toString是Object类的方法

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

 

       ArrayList al = new ArrayList();

       al.add(1);

       al.add(3);

       al.add(2);

 

       out.println(al);

 

        sort(al);

       out.println(al);

    }

}<span style="font-family:Calibri;font-size:14px;"> </span>