你的位置:首页 > Java教程

[Java教程]JAVA基础学习day17


一、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...34lisi002...16lisi009...16lisi001...23排序后:lisi002...16lisi009...16lisi001...23lisi005...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);    int index = Collections.binarySearch(list, "dee");// 1    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);// 3    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 intbinarySearch(byte[] a, byte key)
使用二分搜索法来搜索指定的 byte 型数组,以获得指定的值。
static intbinarySearch(byte[] a, int fromIndex, int toIndex, byte key)
使用二分搜索法来搜索指定的 byte 型数组的范围,以获得指定的值。
static intbinarySearch(char[] a, char key)
使用二分搜索法来搜索指定的 char 型数组,以获得指定的值。
static intbinarySearch(char[] a, int fromIndex, int toIndex, char key)
使用二分搜索法来搜索指定的 char 型数组的范围,以获得指定的值。
static intbinarySearch(double[] a, double key)
使用二分搜索法来搜索指定的 double 型数组,以获得指定的值。
static intbinarySearch(double[] a, int fromIndex, int toIndex, double key)
使用二分搜索法来搜索指定的 double 型数组的范围,以获得指定的值。
static intbinarySearch(float[] a, float key)
使用二分搜索法来搜索指定的 float 型数组,以获得指定的值。
static intbinarySearch(float[] a, int fromIndex, int toIndex, float key)
使用二分搜索法来搜索指定的 float 型数组的范围,以获得指定的值。
static intbinarySearch(int[] a, int key)
使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。
static intbinarySearch(int[] a, int fromIndex, int toIndex, int key)
使用二分搜索法来搜索指定的 int 型数组的范围,以获得指定的值。
static intbinarySearch(long[] a, int fromIndex, int toIndex, long key)
使用二分搜索法来搜索指定的 long 型数组的范围,以获得指定的值。
static intbinarySearch(long[] a, long key)
使用二分搜索法来搜索指定的 long 型数组,以获得指定的值。
static intbinarySearch(Object[] a, int fromIndex, int toIndex, Object key)
使用二分搜索法来搜索指定数组的范围,以获得指定对象。
static intbinarySearch(Object[] a, Object key)
使用二分搜索法来搜索指定数组,以获得指定对象。
static intbinarySearch(short[] a, int fromIndex, int toIndex, short key)
使用二分搜索法来搜索指定的 short 型数组的范围,以获得指定的值。
static intbinarySearch(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 booleandeepEquals(Object[] a1, Object[] a2)
如果两个指定数组彼此是深层相等 的,则返回 true
static intdeepHashCode(Object[] a)
基于指定数组的“深层内容”返回哈希码。
static StringdeepToString(Object[] a)
返回指定数组“深层内容”的字符串表示形式。
static booleanequals(boolean[] a, boolean[] a2)
如果两个指定的 boolean 型数组彼此相等,则返回 true
static booleanequals(byte[] a, byte[] a2)
如果两个指定的 byte 型数组彼此相等,则返回 true
static booleanequals(char[] a, char[] a2)
如果两个指定的 char 型数组彼此相等,则返回 true
static booleanequals(double[] a, double[] a2)
如果两个指定的 double 型数组彼此相等,则返回 true
static booleanequals(float[] a, float[] a2)
如果两个指定的 float 型数组彼此相等,则返回 true
static booleanequals(int[] a, int[] a2)
如果两个指定的 int 型数组彼此相等,则返回 true
static booleanequals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等,则返回 true
static booleanequals(Object[] a, Object[] a2)
如果两个指定的 Objects 数组彼此相等,则返回 true
static booleanequals(short[] a, short[] a2)
如果两个指定的 short 型数组彼此相等,则返回 true
static voidfill(boolean[] a, boolean val)
将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
static voidfill(boolean[] a, int fromIndex, int toIndex, boolean val)
将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
static voidfill(byte[] a, byte val)
将指定的 byte 值分配给指定 byte 节型数组的每个元素。
static voidfill(byte[] a, int fromIndex, int toIndex, byte val)
将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。
static voidfill(char[] a, char val)
将指定的 char 值分配给指定 char 型数组的每个元素。
static voidfill(char[] a, int fromIndex, int toIndex, char val)
将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。
static voidfill(double[] a, double val)
将指定的 double 值分配给指定 double 型数组的每个元素。
static voidfill(double[] a, int fromIndex, int toIndex, double val)
将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。
static voidfill(float[] a, float val)
将指定的 float 值分配给指定 float 型数组的每个元素。
static voidfill(float[] a, int fromIndex, int toIndex, float val)
将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。
static voidfill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组的每个元素。
static voidfill(int[] a, int fromIndex, int toIndex, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
static voidfill(long[] a, int fromIndex, int toIndex, long val)
将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。
static voidfill(long[] a, long val)
将指定的 long 值分配给指定 long 型数组的每个元素。
static voidfill(Object[] a, int fromIndex, int toIndex, Object val)
将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static voidfill(Object[] a, Object val)
将指定的 Object 引用分配给指定 Object 数组的每个元素。
static voidfill(short[] a, int fromIndex, int toIndex, short val)
将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。
static voidfill(short[] a, short val)
将指定的 short 值分配给指定 short 型数组的每个元素。
static inthashCode(boolean[] a)
基于指定数组的内容返回哈希码。
static inthashCode(byte[] a)
基于指定数组的内容返回哈希码。
static inthashCode(char[] a)
基于指定数组的内容返回哈希码。
static inthashCode(double[] a)
基于指定数组的内容返回哈希码。
static inthashCode(float[] a)
基于指定数组的内容返回哈希码。
static inthashCode(int[] a)
基于指定数组的内容返回哈希码。
static inthashCode(long[] a)
基于指定数组的内容返回哈希码。
static inthashCode(Object[] a)
基于指定数组的内容返回哈希码。
static inthashCode(short[] a)
基于指定数组的内容返回哈希码。
static voidsort(byte[] a)
对指定的 byte 型数组按数字升序进行排序。
static voidsort(byte[] a, int fromIndex, int toIndex)
对指定 byte 型数组的指定范围按数字升序进行排序。
static voidsort(char[] a)
对指定的 char 型数组按数字升序进行排序。
static voidsort(char[] a, int fromIndex, int toIndex)
对指定 char 型数组的指定范围按数字升序进行排序。
static voidsort(double[] a)
对指定的 double 型数组按数字升序进行排序。
static voidsort(double[] a, int fromIndex, int toIndex)
对指定 double 型数组的指定范围按数字升序进行排序。
static voidsort(float[] a)
对指定的 float 型数组按数字升序进行排序。
static voidsort(float[] a, int fromIndex, int toIndex)
对指定 float 型数组的指定范围按数字升序进行排序。
static voidsort(int[] a)
对指定的 int 型数组按数字升序进行排序。
static voidsort(int[] a, int fromIndex, int toIndex)
对指定 int 型数组的指定范围按数字升序进行排序。
static voidsort(long[] a)
对指定的 long 型数组按数字升序进行排序。
static voidsort(long[] a, int fromIndex, int toIndex)
对指定 long 型数组的指定范围按数字升序进行排序。
static voidsort(Object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。
static voidsort(Object[] a, int fromIndex, int toIndex)
根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static voidsort(short[] a)
对指定的 short 型数组按数字升序进行排序。
static voidsort(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 StringtoString(boolean[] a)
返回指定数组内容的字符串表示形式。
static StringtoString(byte[] a)
返回指定数组内容的字符串表示形式。
static StringtoString(char[] a)
返回指定数组内容的字符串表示形式。
static StringtoString(double[] a)
返回指定数组内容的字符串表示形式。
static StringtoString(float[] a)
返回指定数组内容的字符串表示形式。
static StringtoString(int[] a)
返回指定数组内容的字符串表示形式。
static StringtoString(long[] a)
返回指定数组内容的字符串表示形式。
static StringtoString(Object[] a)
返回指定数组内容的字符串表示形式。
static StringtoString(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长度33...4...5...长度48...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)); //显示的输入使用哪个类的哪个方法      }}