一、Collection简述1.1、Collection与Collections的区别
Collections是集合的静态工具类
Collection:是集合的顶级接口
二、Sort2.1、sort
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;/*** 对字符串进行自然排序
**/publicclassSortDemo1 {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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);
}
}
示例二、
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;/*** 按字符串长度排序，倒序
**/publicclassSortDemo2 {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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,newStringLengthSort());
System.out.println("排序后:"+list);
}
}classStringLengthSortimplementsComparator<String>{
@Overridepublicintcompare(String s1, String s2) {intnum=newInteger(s2.length()).compareTo(newInteger(s1.length()));if(num==0){returns1.compareTo(s1);
}returnnum;
}
}
三、max
3.1、max
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;/** 求最大值*/publicclassMaxDemo1 {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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
对象求最大值：
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;/*** 求对象的最大值：
*1.类本身实现比较功能或者使用比较器
*2.按对象的age求最大值*/classPerson{privateString name;privateintage;publicPerson(String name,intage) {super();this.name =name;this.age =age;
}publicPerson() {super();//TODO Auto-generated constructor stub}publicString getName() {returnname;
}publicvoidsetName(String name) {this.name =name;
}publicintgetAge() {returnage;
}publicvoidsetAge(intage) {this.age =age;
}
}publicclassMaxPersonTest {publicstaticvoidmain(String[] args) {
ArrayList<Person> list =newArrayList<Person>();
list.add(newPerson("lisi005",34));
list.add(newPerson("lisi002",16));
list.add(newPerson("lisi009",16));
list.add(newPerson("lisi001",23));
System.out.println("未排序：:");
sop(list);//排序Collections.sort(list,newPersonCom());
System.out.println("排序后:");
sop(list);
Person maxPerson=Collections.max(list,newPersonCom());
System.out.println("年龄最大的人："+maxPerson.getName()+"..."+maxPerson.getAge());
}publicstaticvoidsop(ArrayList<Person>list){for(Person p:list){
System.out.println(p.getName()+"..."+p.getAge());
}
}
}classPersonComimplementsComparator<Person>{publicintcompare(Person p1,Person p2){intnum=newInteger(p1.getAge()).compareTo(newInteger(p2.getAge()));if(num==0){returnp1.getName().compareTo(p2.getName());
}returnnum;
}
}//结果：未排序：:
lisi005...34lisi002...16lisi009...16lisi001...23排序后:
lisi002...16lisi009...16lisi001...23lisi005...34年龄最大的人：lisi005...34
四、binarySearch 4.1、binarySearch
用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过sort(List)方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。
参数：list- 要搜索的列表。key- 要搜索的键。返回：如果搜索键包含在列表中，则返回搜索键的索引；否则返回(-(插入点) - 1)。插入点被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.List;publicclassBinarSearchDemo {publicstaticvoidmain(String[] args) {
ArrayList<String> list =newArrayList<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);intindex = Collections.binarySearch(list, "dee");//1System.out.println("index=" +index);intindex1 = Collections.binarySearch(list, "deed");
System.out.println("index1=" + index1);//没有返回-（插入点）一1 -（2）-1 结果-3//测试intindex2 = halfSearch(list, "z");
System.out.println("index2=" + index2);//3intindex3 = halfSearch(list, "zdd");
System.out.println("index3=" + index3);//-5//测试intindex4 = halfSearch2(list, "z",newMyComp());
System.out.println("index4=" + index4);//intindex5 = halfSearch2(list, "zdd",newMyComp());
System.out.println("index5=" + index5);//}//手动实现二分法查找publicstaticinthalfSearch(List<String>list, String key) {intmax = list.size() - 1;intmin = 0;intmid;while(min <=max) {
mid= (min + max) >>> 1;//除2String str = list.get(mid);//中间值intnum =str.compareTo(key);if(num > 0) {
max= mid - 1;
}elseif(num < 0) {
min= mid + 1;
}else{returnmid;
}
}return-min - 1;//返回-(插入点)-1}//手动实现二分法查找,添加比较器publicstaticinthalfSearch2(List<String> list, String key, Comparator<String>com) {intmax = list.size() - 1;intmin = 0;intmid;while(min <=max) {
mid= (min + max) >>> 1;//除2String str = list.get(mid);//中间值intnum =com.compare(str, key);if(num > 0) {
max= mid - 1;
}elseif(num < 0) {
min= mid + 1;
}else{returnmid;
}
}return-min - 1;//返回-(插入点)-1}
}classMyCompimplementsComparator<String>{
@Overridepublicintcompare(String s1, String s2) {intnum=newInteger(s2.length()).compareTo(newInteger(s1.length()));if(num==0){returns1.compareTo(s1);
}returnnum;
}
}
[abd, dee, fsdfdsfd, z, zf, zfdsfd]
index=1
index1=-3
index2=3
index3=-5
index4=-7
index5=-4
五、fill
5.1、fill
使用指定元素替换指定列表中的所有元素。
此方法以线性时间运行。
参数：list- 使用指定元素填充的列表。obj- 用来填充指定列表的元素。 packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;publicclassFillDemo {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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]
示例二、
packagecom.pb.sort.demo1;importjava.util.ArrayList;/*** 将指定索引的元素替换
**/publicclassFillDemo {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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);
}publicstaticArrayList<String> fill(ArrayList<String> list,intstart,intend,String key){for(intx=start;x<end;x++){
list.set(x, key);
}returnlist;
}
}//结果[zfdsfd, dee, hello, hello, abd, zb]
六、replaceAll
6.1、replaceAll
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;publicclassReplaceAllDemo {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;publicclassReplaceAllDemo {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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 的自然顺序。packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.TreeSet;publicclassReverseOrder {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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=newTreeSet<String>(Collections.reverseOrder(newStrLencom()));
ts.add("cccccc");
ts.add("dddd");
ts.add("a");
ts.add("hh");
System.out.println(ts);
}
}classStrLencomimplementsComparator<String>{
@Overridepublicintcompare(String s1, String s2) {intnum=newInteger(s1.length()).compareTo(newInteger(s2.length()));if(num==0){returns1.compareTo(s2);
}returnnum;
}
}//结果：[a, bdc, hg, uioew]
[uioew, hg, bdc, a]
[cccccc, dddd, hh, a]
八、swap8.1、swap
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;publicclassSwapDemo {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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]
九、shuffle9.1、shuffle
使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Random;publicclassSwapDemo {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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,newRandom(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、数组转集合
数组转集合不可以用集合的：增加，删除
packagecom.pb.sort.demo1;importjava.util.Arrays;importjava.util.List;publicclassArrayToList {publicstaticvoidmain(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循环
packagecom.pb.sort.demo1;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.HashSet;importjava.util.Map;importjava.util.Set;publicclassForEachDemo {publicstaticvoidmain(String[] args) {
ArrayList<String> list=newArrayList<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=newHashSet<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=newHashMap<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、可变参数
packagecom.pb.sort.demo1;publicclassParamsDemo {publicstaticvoidmain(String[] args) {
show();
show(3,4,5);
show(8,9,10,99);
}publicstaticvoidshow(int...arr){//..可变参数自动封装为数组System.out.println("长度"+arr.length);for(inti:arr){
System.out.println(i+"...");
}
}
}
长度0
长度33...4...5...
长度48...9...10...99...
可变参数类型必须为同一类型
packagecom.pb.sort.demo1;publicclassParamsDemo {publicstaticvoidmain(String[] args) {
show("hello");
show("java",3,4,5);
show("world",8,9,10,99);
}publicstaticvoidshow(String str,int...arr){//..可变参数自动封装为数组 可变参数要定义在参数列表 的后面System.out.println("长度"+arr.length);for(inti:arr){
System.out.println(i+"...");
}
}
}
十四、静态导入14.1、静态导入
static import静态导入
当方法重名里：指定具备所属的对象或者类
packagecom.pb.sort.demo1;importstaticjava.util.Arrays.*;//导入Arrays类中的方法可以直接使用方法importjava.util.Arrays;importstaticjava.lang.System.*;publicclassStaticImportDemoextendsObject {publicstaticvoidmain(String[] args) {
String [] arr={"abc","b","a","ab","d"};//直接使用排序方法sort(arr);intindex=binarySearch(arr, "d");
System.out.println("index="+index);//静态导入了System.可以直接使用out.println(Arrays.toString(arr));//显示的输入使用哪个类的哪个方法}
}