一、Collection简述

1.1、Collection与Collections的区别

Collections是集合的静态工具类

Collection:是集合的顶级接口

二、Sort

2.1、sort

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;

/**
 * 对字符串进行自然排序
 *
 */
public class SortDemo1 {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("z");
        System.out.println("未排序"+list);
        //自然排序
        Collections.sort(list);
        System.out.println("排序后"+list);

    }

}

示例二、

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
 * 按字符串长度排序,倒序
 *
 */
public class SortDemo2 {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("z");
        System.out.println("未排序"+list);
        Collections.sort(list, new StringLengthSort());
        System.out.println("排序后:"+list);
    }

}
class StringLengthSort implements Comparator<String>{

    @Override
    public int compare(String s1, String s2) {
        int num=new Integer(s2.length()).compareTo(new Integer(s1.length()));
        if(num==0){
            return s1.compareTo(s1);
        }
        return num;
    }

}

三、max

3.1、max

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;
/*
 * 求最大值
 */
public class MaxDemo1 {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("z");
        Collections.sort(list);
        System.out.println(list);
        String max=Collections.max(list);
        System.out.println("max="+max);
    }

}
//结果
[abd, dee, fsdfdsfd, z, z, zfdsfd]
max=zfdsfd

对象求最大值:

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * 求对象的最大值:
 *1.类本身实现比较功能或者使用比较器
 *2.按对象的age求最大值
 */
class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}

public class MaxPersonTest {

    public static void main(String[] args) {
        ArrayList<Person> list =new ArrayList<Person>();
        list.add(new Person("lisi005",34));
        list.add(new Person("lisi002",16));
        list.add(new Person("lisi009",16));
        list.add(new Person("lisi001",23));
        System.out.println("未排序::");
        sop(list);
        //排序
        Collections.sort(list,new PersonCom());
        System.out.println("排序后:");
        sop(list);
        Person maxPerson=Collections.max(list, new PersonCom());
        System.out.println("年龄最大的人:"+maxPerson.getName()+"..."+maxPerson.getAge());
    }
    public static void sop(ArrayList<Person> list){
        for(Person p:list){
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }

}
class PersonCom implements Comparator<Person>{
    public int compare(Person p1,Person p2){
        int num=new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
        if(num==0){
            return p1.getName().compareTo(p2.getName());
        }
        return num;
    }
}

//结果:
未排序::
lisi005...34
lisi002...16
lisi009...16
lisi001...23
排序后:
lisi002...16
lisi009...16
lisi001...23
lisi005...34
年龄最大的人:lisi005...34

四、binarySearch

4.1、binarySearch

用二分搜索法搜索指定列表,以获得指定对象。在进行此调用之前,必须根据列表元素的自然顺序对列表进行升序排序(通过 sort(List) 方法)。如果没有对列表进行排序,则结果是不确定的。如果列表包含多个等于指定对象的元素,则无法保证找到的是哪一个。

参数:list - 要搜索的列表。key - 要搜索的键。返回:如果搜索键包含在列表中,则返回搜索键的索引;否则返回 (-(插入点) - 1)插入点 被定义为将键插入列表的那一点:即第一个大于此键的元素索引;如果列表中的所有元素都小于指定的键,则为 list.size()。注意,这保证了当且仅当此键被找到时,返回的值将 >= 0

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class BinarSearchDemo {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("zf");
        Collections.sort(list);
        System.out.println(list);

        System.out.println("index=" + index);
        int index1 = Collections.binarySearch(list, "deed");
        System.out.println("index1=" + index1);// 没有返回-(插入点)一1 -(2)-1 结果-3

        // 测试
        int index2 = halfSearch(list, "z");
        System.out.println("index2=" + index2);
        int index3 = halfSearch(list, "zdd");
        System.out.println("index3=" + index3);// -5

        // 测试
        int index4 = halfSearch2(list, "z",new MyComp());
        System.out.println("index4=" + index4);//
        int index5 = halfSearch2(list, "zdd",new MyComp());
        System.out.println("index5=" + index5);//

    }

    // 手动实现二分法查找
    public static int halfSearch(List<String> list, String key) {
        int max = list.size() - 1;
        int min = 0;
        int mid;
        while (min <= max) {
            mid = (min + max) >>> 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; // 返回-(插入点)-1
    }

    // 手动实现二分法查找,添加比较器
    public static int halfSearch2(List<String> list, String key, Comparator<String> com) {
        int max = list.size() - 1;
        int min = 0;
        int mid;
        while (min <= max) {
            mid = (min + max) >>> 1; // 除2
            String str = list.get(mid); // 中间值
            int num = com.compare(str, key);
            if (num > 0) {
                max = mid - 1;
            } else if (num < 0) {
                min = mid + 1;
            } else {
                return mid;
            }
        }
        return -min - 1; // 返回-(插入点)-1
    }

}
class MyComp implements Comparator<String>{

    @Override
    public int compare(String s1, String s2) {
        int num=new Integer(s2.length()).compareTo(new Integer(s1.length()));
        if(num==0){
            return s1.compareTo(s1);
        }
        return num;
    }

}

[abd, dee, fsdfdsfd, z, zf, zfdsfd]
index=1
index1=-3
index2=3
index3=-5
index4=-7
index5=-4

五、fill

5.1、fill

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

此方法以线性时间运行。

参数:
list - 使用指定元素填充的列表。
obj - 用来填充指定列表的元素。 
package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;

public class FillDemo {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("zb");
        Collections.fill(list,"pp");
        System.out.println(list);

    }

}//结果:[pp, pp, pp, pp, pp, pp]

示例二、

package com.pb.sort.demo1;

import java.util.ArrayList;
/**
 * 将指定索引的元素替换
 *
 */

public class FillDemo {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("zb");
        //将指定位置的元素替换
        list=fill(list,2,4,"hello");
        System.out.println(list);

    }
    public static ArrayList<String> fill(ArrayList<String> list, int start,int end,String key){
        for(int x=start;x<end;x++){
            list.set(x, key);

        }

        return list;

    }

}
//结果
[zfdsfd, dee, hello, hello, abd, zb]

六、replaceAll

6.1、replaceAll

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;

public class ReplaceAllDemo {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("zb");
        Collections.replaceAll(list, "z", "java");
        System.out.println(list);

    }

}

七、reverse与reverseOrder

7.1、reverse

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;

public class ReplaceAllDemo {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("zb");
        Collections.reverse(list);
        System.out.println(list);

    }

}

7.2、reverseOrder

返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。(自然顺序是通过对象自身的 compareTo 方法强行排序的。)此方法允许使用单个语句,以逆自然顺序对实现了 Comparable 接口的对象 collection(或数组)进行排序(或维护)。例如,假设 a 是一个字符串数组。那么:

                Arrays.sort(a, Collections.reverseOrder());

将按照逆字典(字母)顺序对数组进行排序。

返回的比较器是可序列化的。

返回:
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.TreeSet;

public class ReverseOrder {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("bdc");
        list.add("uioew");
        list.add("a");
        list.add("hg");
        Collections.sort(list);
        System.out.println(list);
        Collections.sort(list, Collections.reverseOrder());
        System.out.println(list);
        TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new StrLencom()));
        ts.add("cccccc");
        ts.add("dddd");
        ts.add("a");
        ts.add("hh");
        System.out.println(ts);

    }

}
class StrLencom implements Comparator<String>{

    @Override
    public int compare(String s1, String s2) {
        int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num==0){
            return s1.compareTo(s2);
        }
        return num;
    }

}
//结果:

[a, bdc, hg, uioew]
[uioew, hg, bdc, a]
[cccccc, dddd, hh, a]

八、swap

8.1、swap

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;

public class SwapDemo {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("bdc");
        list.add("uioew");
        list.add("a");
        list.add("hg");
        System.out.println(list);
        //交换指定下位的2个元素
        Collections.swap(list, 2, 0);
        System.out.println(list);

    }

}
//结果
[bdc, uioew, a, hg]
[a, uioew, bdc, hg]

九、shuffle

9.1、shuffle

使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class SwapDemo {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("bdc");
        list.add("uioew");
        list.add("a");
        list.add("hg");
        System.out.println(list);
        //交换指定下位的2个元素
        Collections.shuffle(list);
        System.out.println(list);
        Collections.shuffle(list,new Random(list.size()+1));
        System.out.println(list);

    }

}

第二,第三都随机的每次运行不一样

[bdc, uioew, a, hg]
[hg, a, bdc, uioew]
[uioew, hg, a, bdc]

十、Arrays

10.1、Arrays

操作数组的静态工具类,和使用Collection方法一样

方法摘要
static

<T> List<T>
asList(T... a)
返回一个受指定数组支持的固定大小的列表。
static int binarySearch(byte[] a,
byte key)

使用二分搜索法来搜索指定的 byte 型数组,以获得指定的值。
static int binarySearch(byte[] a,
int fromIndex, int toIndex, byte key)

使用二分搜索法来搜索指定的 byte
型数组的范围,以获得指定的值。
static int binarySearch(char[] a,
char key)

使用二分搜索法来搜索指定的 char 型数组,以获得指定的值。
static int binarySearch(char[] a,
int fromIndex, int toIndex, char key)

使用二分搜索法来搜索指定的 char
型数组的范围,以获得指定的值。
static int binarySearch(double[] a,
double key)

使用二分搜索法来搜索指定的 double 型数组,以获得指定的值。
static int binarySearch(double[] a,
int fromIndex, int toIndex, double key)

使用二分搜索法来搜索指定的
double 型数组的范围,以获得指定的值。
static int binarySearch(float[] a,
float key)

使用二分搜索法来搜索指定的 float 型数组,以获得指定的值。
static int binarySearch(float[] a,
int fromIndex, int toIndex, float key)

使用二分搜索法来搜索指定的 float
型数组的范围,以获得指定的值。
static int binarySearch(int[] a,
int key)

使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。
static int binarySearch(int[] a,
int fromIndex, int toIndex, int key)

使用二分搜索法来搜索指定的 int
型数组的范围,以获得指定的值。
static int binarySearch(long[] a,
int fromIndex, int toIndex, long key)

使用二分搜索法来搜索指定的 long
型数组的范围,以获得指定的值。
static int binarySearch(long[] a,
long key)

使用二分搜索法来搜索指定的 long 型数组,以获得指定的值。
static int binarySearch(Object[] a,
int fromIndex, int toIndex, Object key)


使用二分搜索法来搜索指定数组的范围,以获得指定对象。
static int binarySearch(Object[] a, Object key)

使用二分搜索法来搜索指定数组,以获得指定对象。
static int binarySearch(short[] a,
int fromIndex, int toIndex, short key)

使用二分搜索法来搜索指定的 short
型数组的范围,以获得指定的值。
static int binarySearch(short[] a,
short key)

使用二分搜索法来搜索指定的 short 型数组,以获得指定的值。
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)


使用二分搜索法来搜索指定数组,以获得指定对象。
static boolean[] copyOf(boolean[] original,
int newLength)

复制指定的数组,截取或用 false
填充(如有必要),以使副本具有指定的长度。
static byte[] copyOf(byte[] original,
int newLength)

复制指定的数组,截取或用 0
填充(如有必要),以使副本具有指定的长度。
static char[] copyOf(char[] original,
int newLength)

复制指定的数组,截取或用 null
字符填充(如有必要),以使副本具有指定的长度。
static double[] copyOf(double[] original,
int newLength)

复制指定的数组,截取或用 0
填充(如有必要),以使副本具有指定的长度。
static float[] copyOf(float[] original,
int newLength)

复制指定的数组,截取或用 0
填充(如有必要),以使副本具有指定的长度。
static int[] copyOf(int[] original,
int newLength)

复制指定的数组,截取或用 0
填充(如有必要),以使副本具有指定的长度。
static long[] copyOf(long[] original,
int newLength)

复制指定的数组,截取或用 0
填充(如有必要),以使副本具有指定的长度。
static short[] copyOf(short[] original,
int newLength)

复制指定的数组,截取或用 0
填充(如有必要),以使副本具有指定的长度。
static

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

复制指定的数组,截取或用 null
填充(如有必要),以使副本具有指定的长度。
static

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


复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。
static boolean[] copyOfRange(boolean[] original,
int from, int to)

将指定数组的指定范围复制到一个新数组。
static byte[] copyOfRange(byte[] original,
int from, int to)

将指定数组的指定范围复制到一个新数组。
static char[] copyOfRange(char[] original,
int from, int to)

将指定数组的指定范围复制到一个新数组。
static double[] copyOfRange(double[] original,
int from, int to)

将指定数组的指定范围复制到一个新数组。
static float[] copyOfRange(float[] original,
int from, int to)

将指定数组的指定范围复制到一个新数组。
static int[] copyOfRange(int[] original,
int from, int to)

将指定数组的指定范围复制到一个新数组。
static long[] copyOfRange(long[] original,
int from, int to)

将指定数组的指定范围复制到一个新数组。
static short[] copyOfRange(short[] 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)


将指定数组的指定范围复制到一个新数组。
static boolean deepEquals(Object[] a1, Object[] a2)

如果两个指定数组彼此是深层相等 的,则返回 true
static int deepHashCode(Object[] a)

基于指定数组的“深层内容”返回哈希码。
static String deepToString(Object[] a)

返回指定数组“深层内容”的字符串表示形式。
static boolean equals(boolean[] a,
boolean[] a2)

如果两个指定的 boolean 型数组彼此相等,则返回
true
static boolean equals(byte[] a,
byte[] a2)

如果两个指定的 byte 型数组彼此相等,则返回
true
static boolean equals(char[] a,
char[] a2)

如果两个指定的 char 型数组彼此相等,则返回
true
static boolean equals(double[] a,
double[] a2)

如果两个指定的 double 型数组彼此相等,则返回
true
static boolean equals(float[] a,
float[] a2)

如果两个指定的 float 型数组彼此相等,则返回
true
static boolean equals(int[] a,
int[] a2)

如果两个指定的 int 型数组彼此相等,则返回
true
static boolean equals(long[] a,
long[] a2)

如果两个指定的 long 型数组彼此相等,则返回
true
static boolean equals(Object[] a, Object[] a2)

如果两个指定的 Objects 数组彼此相等,则返回 true
static boolean equals(short[] a,
short[] a2)

如果两个指定的 short 型数组彼此相等,则返回
true
static void fill(boolean[] a,
boolean val)

将指定的 boolean 值分配给指定 boolean
型数组的每个元素。
static void fill(boolean[] a,
int fromIndex, int toIndex, boolean val)

将指定的 boolean
值分配给指定 boolean 型数组指定范围中的每个元素。
static void fill(byte[] a,
byte val)

将指定的 byte 值分配给指定 byte 节型数组的每个元素。
static void fill(byte[] a,
int fromIndex, int toIndex, byte val)

将指定的 byte 值分配给指定 byte
型数组指定范围中的每个元素。
static void fill(char[] a,
char val)

将指定的 char 值分配给指定 char 型数组的每个元素。
static void fill(char[] a,
int fromIndex, int toIndex, char val)

将指定的 char 值分配给指定 char
型数组指定范围中的每个元素。
static void fill(double[] a,
double val)

将指定的 double 值分配给指定 double 型数组的每个元素。
static void fill(double[] a,
int fromIndex, int toIndex, double val)

将指定的 double 值分配给指定
double 型数组指定范围中的每个元素。
static void fill(float[] a,
float val)

将指定的 float 值分配给指定 float 型数组的每个元素。
static void fill(float[] a,
int fromIndex, int toIndex, float val)

将指定的 float 值分配给指定
float 型数组指定范围中的每个元素。
static void fill(int[] a,
int val)

将指定的 int 值分配给指定 int 型数组的每个元素。
static void fill(int[] a,
int fromIndex, int toIndex, int val)

将指定的 int 值分配给指定 int
型数组指定范围中的每个元素。
static void fill(long[] a,
int fromIndex, int toIndex, long val)

将指定的 long 值分配给指定 long
型数组指定范围中的每个元素。
static void fill(long[] a,
long val)

将指定的 long 值分配给指定 long 型数组的每个元素。
static void fill(Object[] a,
int fromIndex, int toIndex, Object val)

将指定的
Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void fill(Object[] a, Object val)

将指定的 Object 引用分配给指定 Object 数组的每个元素。
static void fill(short[] a,
int fromIndex, int toIndex, short val)

将指定的 short 值分配给指定
short 型数组指定范围中的每个元素。
static void fill(short[] a,
short val)

将指定的 short 值分配给指定 short 型数组的每个元素。
static int hashCode(boolean[] a)

基于指定数组的内容返回哈希码。
static int hashCode(byte[] a)

基于指定数组的内容返回哈希码。
static int hashCode(char[] a)

基于指定数组的内容返回哈希码。
static int hashCode(double[] a)

基于指定数组的内容返回哈希码。
static int hashCode(float[] a)

基于指定数组的内容返回哈希码。
static int hashCode(int[] a)

基于指定数组的内容返回哈希码。
static int hashCode(long[] a)

基于指定数组的内容返回哈希码。
static int hashCode(Object[] a)

基于指定数组的内容返回哈希码。
static int hashCode(short[] a)

基于指定数组的内容返回哈希码。
static void sort(byte[] a)

对指定的 byte 型数组按数字升序进行排序。
static void sort(byte[] a,
int fromIndex, int toIndex)

对指定 byte
型数组的指定范围按数字升序进行排序。
static void sort(char[] a)

对指定的 char 型数组按数字升序进行排序。
static void sort(char[] a,
int fromIndex, int toIndex)

对指定 char
型数组的指定范围按数字升序进行排序。
static void sort(double[] a)

对指定的 double 型数组按数字升序进行排序。
static void sort(double[] a,
int fromIndex, int toIndex)

对指定 double
型数组的指定范围按数字升序进行排序。
static void sort(float[] a)

对指定的 float 型数组按数字升序进行排序。
static void sort(float[] a,
int fromIndex, int toIndex)

对指定 float
型数组的指定范围按数字升序进行排序。
static void sort(int[] a)

对指定的 int 型数组按数字升序进行排序。
static void sort(int[] a,
int fromIndex, int toIndex)

对指定 int
型数组的指定范围按数字升序进行排序。
static void sort(long[] a)

对指定的 long 型数组按数字升序进行排序。
static void sort(long[] a,
int fromIndex, int toIndex)

对指定 long
型数组的指定范围按数字升序进行排序。
static void sort(Object[] a)

根据元素的自然顺序对指定对象数组按升序进行排序。
static void sort(Object[] a,
int fromIndex, int toIndex)

根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static void sort(short[] a)

对指定的 short 型数组按数字升序进行排序。
static void sort(short[] a,
int fromIndex, int toIndex)

对指定 short
型数组的指定范围按数字升序进行排序。
static

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


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

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


根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
static String toString(boolean[] a)

返回指定数组内容的字符串表示形式。
static String toString(byte[] a)

返回指定数组内容的字符串表示形式。
static String toString(char[] a)

返回指定数组内容的字符串表示形式。
static String toString(double[] a)

返回指定数组内容的字符串表示形式。
static String toString(float[] a)

返回指定数组内容的字符串表示形式。
static String toString(int[] a)

返回指定数组内容的字符串表示形式。
static String toString(long[] a)

返回指定数组内容的字符串表示形式。
static String toString(Object[] a)

返回指定数组内容的字符串表示形式。
static String toString(short[] a)

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


十一、数组和集合相互转换

11.1、数组转集合

数组转集合不可以用集合的:增加,删除

package com.pb.sort.demo1;

import java.util.Arrays;
import java.util.List;

public class ArrayToList {

    public static void main(String[] args) {
        String[] arr={"bde","aab","bc","dd"};
        //转换集合 数组转集合不可以用集合的:增加,删除
        List<String> list=Arrays.asList(arr);
        list.set(2, "hello");
        System.out.println(list.contains("dd"));
        System.out.println(list);

    }

}

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

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

十二、增强for循环

12.1、增强for循环

package com.pb.sort.demo1;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class ForEachDemo {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("zfdsfd");
        list.add("dee");
        list.add("z");
        list.add("fsdfdsfd");
        list.add("abd");
        list.add("z");
        for(String s:list){
            System.out.println(s);
        }
        Set<Integer> set=new HashSet<Integer>();
        set.add(3);
        set.add(2);
        set.add(2);
        set.add(5);
        for(Integer i:set){
            System.out.println(i);
        }
        Map<String,Integer> map=new HashMap<String,Integer>();
        map.put("001", 3);
        map.put("002", 5);
        map.put("006", 1);
        map.put("003", 113);
        for(String s:map.keySet()){
            System.out.println(s+".."+map.get(s));
        }
        for(Map.Entry<String, Integer> me:map.entrySet()){
            System.out.println(me.getKey()+"..."+me.getValue());
        }
    }

}

十三、可变参数

13.1、可变参数

package com.pb.sort.demo1;

public class ParamsDemo {

    public static void main(String[] args) {
        show();
        show(3,4,5);
        show(8,9,10,99);
    }
    public static void show(int ...arr){//..可变参数自动封装为数组
        System.out.println("长度"+arr.length);
        for(int i:arr){
            System.out.println(i+"...");
        }

    }

}
长度0
长度3
3...
4...
5...
长度4
8...
9...
10...
99...

可变参数类型必须为同一类型

package com.pb.sort.demo1;

public class ParamsDemo {

    public static void main(String[] args) {
        show("hello");
        show("java",3,4,5);
        show("world",8,9,10,99);
    }
    public static void show(String str,int ...arr){//..可变参数自动封装为数组 可变参数要定义在参数列表 的后面
        System.out.println("长度"+arr.length);
        for(int i:arr){
            System.out.println(i+"...");
        }

    }

}

十四、静态导入

14.1、静态导入

static import静态导入

当方法重名里:指定具备所属的对象或者类

package com.pb.sort.demo1;
import static java.util.Arrays.*; //导入Arrays类中的方法可以直接使用方法

import java.util.Arrays;

import static java.lang.System.*;
public class StaticImportDemo extends Object {

    public static void main(String[] args) {
        String [] arr={"abc","b","a","ab","d"};
        //直接使用排序方法
        sort(arr);
        int index=binarySearch(arr, "d");
        System.out.println("index="+index);
        //静态导入了System.可以直接使用
        out.println(Arrays.toString(arr)); //显示的输入使用哪个类的哪个方法

    }

}

JAVA基础学习day17--集合工具类-Collections的更多相关文章

  1. JAVA基础学习day18--常用工具类

    一.System 1.1.概述 System 类包含一些有用的类字段和方法.它不能被实例化. 在 System 类提供的设施中,有标准输入.标准输出和错误输出流:对外部定义的属性和环境变量的访问:加载 ...

  2. Java:集合工具类-Collections

    Java.util.Collections 集合框架工具类Collections,其方法都是静态的,本身没有构造函数. 常见方法: static <T extends Comparable< ...

  3. Java从零开始学二十四(集合工具类Collections)

    一.Collections简介 在集合的应用开发中,集合的若干接口和若干个子类是最最常使用的,但是在JDK中提供了一种集合操作的工具类 —— Collections,可以直接通过此类方便的操作集合 二 ...

  4. Java笔记(二十四)&hellip;&hellip;集合工具类Collections&amp;Arrays

    Collections 集合框架的工具类,方法全部为静态 Collections与Collection的区别 Collection是集合框架的一个顶层接口,里面定义了单列集合的共性方法 Collect ...

  5. Java常用类(五)之集合工具类Collections

    前言 Java提供了一个操作Set.List和Map等集合的工具类:Collections,该工具类提供了大量方法对集合进行排序.查询和修改等操作, 还提供了将集合对象置为不可变.对集合对象实现同步控 ...

  6. [黑马程序员] 集合框架2——Map系 &amp; 集合工具类(Collections、Arrays)

    ---------------------- ASP.Net+Android+IO开发..Net培训.期待与您交流! ---------------------- 0. 集合框架按其所实现的接口, 大 ...

  7. Java 集合工具类---------- Collections类

  8. Java基础学习笔记十二 类、抽象类、接口作为方法参数和返回值以及常用API

    不同修饰符使用细节 常用来修饰类.方法.变量的修饰符 public 权限修饰符,公共访问, 类,方法,成员变量 protected 权限修饰符,受保护访问, 方法,成员变量 默认什么也不写 也是一种权 ...

  9. java基础之日期时间工具类

    package zy.test; import java.sql.Timestamp; import java.text.ParseException; import java.text.ParseP ...

随机推荐

  1. ACE admin 后台管理框架

    一.样式 1.常见按钮 .btn-app .btn-group .btn-corner .btn-xs .btn-sm .btn-mini  .btn-minier .btn-defalut .btn ...

  2. Springlake-02 权限&amp;文档设置&amp;Role设置&amp;Folder设置&amp;登录

    1. 权限 有3个默认的权限用户: 1.System Owner so 管理员权限全部:Type Setup; Group Setup; Form Setup; Role Setup; Share R ...

  3. Java拼接批量新增SQL语句

    StringBuffer addSql = new StringBuffer(1000); int batchSize = 50; int executeTime = 0; SimpleDateFor ...

  4. SuperIndicator 专做轮播图库,没有之一,支持轮播图无限循环

    github地址:https://github.com/hejunlin2013/SuperIndicator SuperIndicator a superindicatorlibray for vi ...

  5. CSS文件中第一行@charset &quot;utf-8&quot;;的作用

    使用UTF-8编码唯一的好处是,国外的用户如果使用Windows XP英文版,浏览UTF-8编码的任何网页,无论是中文.还是日文.韩文.阿拉伯文,都可以正常显示,UTF-8是世界通用的语言编码,而如果 ...

  6. PHPEXCEL使用实例

    最近在项目中要用到PHP生成EXCEL,上网找了一下,发现PHPEXCEL挺不错,用了一下,感觉还行,就是设置单元格格式的时候比较麻烦,总体来说功能还是比较强大的,还有生成PDF什么的,发一个实例吧 ...

  7. TreeView控件绑定数据库

    1.在设计视图里面的代码 <form id="form1" runat="server"> <div> <h1>两个表< ...

  8. .NET 实现DES加密解密处理

    .NET 实现DES加密解密处理 using System; using System.Text; using System.Security.Cryptography; using System.I ...

  9. java的数据类型:基本数据类型和引用数据类型

    Java数据类型的基本概念 数据类型在计算机语言里面,是对内存位置的一个抽象表达方式,可以理解为针对内存的一种抽象的表达方式. 开始接触每种语言的时候,都会存在对数据类型的认识,有复杂的,有复杂的,各 ...

  10. 第二个Sprint冲刺第 七天(燃尽图)