JAVA基础学习day17--集合工具类-Collections
一、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);
int index = Collections.binarySearch(list, "dee");//
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
|
asList(T... a) 返回一个受指定数组支持的固定大小的列表。 |
|
static int |
binarySearch(byte[] a, 使用二分搜索法来搜索指定的 byte 型数组,以获得指定的值。 |
|
static int |
binarySearch(byte[] a, 使用二分搜索法来搜索指定的 byte 型数组的范围,以获得指定的值。 |
|
static int |
binarySearch(char[] a, 使用二分搜索法来搜索指定的 char 型数组,以获得指定的值。 |
|
static int |
binarySearch(char[] a, 使用二分搜索法来搜索指定的 char 型数组的范围,以获得指定的值。 |
|
static int |
binarySearch(double[] a, 使用二分搜索法来搜索指定的 double 型数组,以获得指定的值。 |
|
static int |
binarySearch(double[] a, 使用二分搜索法来搜索指定的 double 型数组的范围,以获得指定的值。 |
|
static int |
binarySearch(float[] a, 使用二分搜索法来搜索指定的 float 型数组,以获得指定的值。 |
|
static int |
binarySearch(float[] a, 使用二分搜索法来搜索指定的 float 型数组的范围,以获得指定的值。 |
|
static int |
binarySearch(int[] a, 使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。 |
|
static int |
binarySearch(int[] a, 使用二分搜索法来搜索指定的 int 型数组的范围,以获得指定的值。 |
|
static int |
binarySearch(long[] a, 使用二分搜索法来搜索指定的 long 型数组的范围,以获得指定的值。 |
|
static int |
binarySearch(long[] a, 使用二分搜索法来搜索指定的 long 型数组,以获得指定的值。 |
|
static int |
binarySearch(Object[] a, 使用二分搜索法来搜索指定数组的范围,以获得指定对象。 |
|
static int |
binarySearch(Object[] a, Object key) 使用二分搜索法来搜索指定数组,以获得指定对象。 |
|
static int |
binarySearch(short[] a, 使用二分搜索法来搜索指定的 short 型数组的范围,以获得指定的值。 |
|
static int |
binarySearch(short[] a, 使用二分搜索法来搜索指定的 short 型数组,以获得指定的值。 |
|
static
|
binarySearch(T[] a, 使用二分搜索法来搜索指定数组的范围,以获得指定对象。 |
|
static
|
binarySearch(T[] a, 使用二分搜索法来搜索指定数组,以获得指定对象。 |
|
static boolean[] |
copyOf(boolean[] original, 复制指定的数组,截取或用 false 填充(如有必要),以使副本具有指定的长度。 |
|
static byte[] |
copyOf(byte[] original, 复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度。 |
|
static char[] |
copyOf(char[] original, 复制指定的数组,截取或用 null 字符填充(如有必要),以使副本具有指定的长度。 |
|
static double[] |
copyOf(double[] original, 复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度。 |
|
static float[] |
copyOf(float[] original, 复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度。 |
|
static int[] |
copyOf(int[] original, 复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度。 |
|
static long[] |
copyOf(long[] original, 复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度。 |
|
static short[] |
copyOf(short[] original, 复制指定的数组,截取或用 0 填充(如有必要),以使副本具有指定的长度。 |
|
static
|
copyOf(T[] original, 复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。 |
|
static
|
copyOf(U[] original, 复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。 |
|
static boolean[] |
copyOfRange(boolean[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static byte[] |
copyOfRange(byte[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static char[] |
copyOfRange(char[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static double[] |
copyOfRange(double[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static float[] |
copyOfRange(float[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static int[] |
copyOfRange(int[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static long[] |
copyOfRange(long[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static short[] |
copyOfRange(short[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static
|
copyOfRange(T[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static
|
copyOfRange(U[] original, 将指定数组的指定范围复制到一个新数组。 |
|
static boolean |
deepEquals(Object[] a1, Object[] a2) 如果两个指定数组彼此是深层相等 的,则返回 true。 |
|
static int |
deepHashCode(Object[] a) 基于指定数组的“深层内容”返回哈希码。 |
|
static String |
deepToString(Object[] a) 返回指定数组“深层内容”的字符串表示形式。 |
|
static boolean |
equals(boolean[] a, 如果两个指定的 boolean 型数组彼此相等,则返回 true。 |
|
static boolean |
equals(byte[] a, 如果两个指定的 byte 型数组彼此相等,则返回 true。 |
|
static boolean |
equals(char[] a, 如果两个指定的 char 型数组彼此相等,则返回 true。 |
|
static boolean |
equals(double[] a, 如果两个指定的 double 型数组彼此相等,则返回 true。 |
|
static boolean |
equals(float[] a, 如果两个指定的 float 型数组彼此相等,则返回 true。 |
|
static boolean |
equals(int[] a, 如果两个指定的 int 型数组彼此相等,则返回 true。 |
|
static boolean |
equals(long[] a, 如果两个指定的 long 型数组彼此相等,则返回 true。 |
|
static boolean |
equals(Object[] a, Object[] a2) 如果两个指定的 Objects 数组彼此相等,则返回 true。 |
|
static boolean |
equals(short[] a, 如果两个指定的 short 型数组彼此相等,则返回 true。 |
|
static void |
fill(boolean[] a, 将指定的 boolean 值分配给指定 boolean 型数组的每个元素。 |
|
static void |
fill(boolean[] a, 将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。 |
|
static void |
fill(byte[] a, 将指定的 byte 值分配给指定 byte 节型数组的每个元素。 |
|
static void |
fill(byte[] a, 将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。 |
|
static void |
fill(char[] a, 将指定的 char 值分配给指定 char 型数组的每个元素。 |
|
static void |
fill(char[] a, 将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。 |
|
static void |
fill(double[] a, 将指定的 double 值分配给指定 double 型数组的每个元素。 |
|
static void |
fill(double[] a, 将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。 |
|
static void |
fill(float[] a, 将指定的 float 值分配给指定 float 型数组的每个元素。 |
|
static void |
fill(float[] a, 将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。 |
|
static void |
fill(int[] a, 将指定的 int 值分配给指定 int 型数组的每个元素。 |
|
static void |
fill(int[] a, 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。 |
|
static void |
fill(long[] a, 将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。 |
|
static void |
fill(long[] a, 将指定的 long 值分配给指定 long 型数组的每个元素。 |
|
static void |
fill(Object[] a, 将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。 |
|
static void |
fill(Object[] a, Object val) 将指定的 Object 引用分配给指定 Object 数组的每个元素。 |
|
static void |
fill(short[] a, 将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。 |
|
static void |
fill(short[] a, 将指定的 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, 对指定 byte 型数组的指定范围按数字升序进行排序。 |
|
static void |
sort(char[] a) 对指定的 char 型数组按数字升序进行排序。 |
|
static void |
sort(char[] a, 对指定 char 型数组的指定范围按数字升序进行排序。 |
|
static void |
sort(double[] a) 对指定的 double 型数组按数字升序进行排序。 |
|
static void |
sort(double[] a, 对指定 double 型数组的指定范围按数字升序进行排序。 |
|
static void |
sort(float[] a) 对指定的 float 型数组按数字升序进行排序。 |
|
static void |
sort(float[] a, 对指定 float 型数组的指定范围按数字升序进行排序。 |
|
static void |
sort(int[] a) 对指定的 int 型数组按数字升序进行排序。 |
|
static void |
sort(int[] a, 对指定 int 型数组的指定范围按数字升序进行排序。 |
|
static void |
sort(long[] a) 对指定的 long 型数组按数字升序进行排序。 |
|
static void |
sort(long[] a, 对指定 long 型数组的指定范围按数字升序进行排序。 |
|
static void |
sort(Object[] a) 根据元素的自然顺序对指定对象数组按升序进行排序。 |
|
static void |
sort(Object[] a, 根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。 |
|
static void |
sort(short[] a) 对指定的 short 型数组按数字升序进行排序。 |
|
static void |
sort(short[] a, 对指定 short 型数组的指定范围按数字升序进行排序。 |
|
static
|
sort(T[] a, 根据指定比较器产生的顺序对指定对象数组进行排序。 |
|
static
|
sort(T[] a, 根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。 |
|
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的更多相关文章
- JAVA基础学习day18--常用工具类
一.System 1.1.概述 System 类包含一些有用的类字段和方法.它不能被实例化. 在 System 类提供的设施中,有标准输入.标准输出和错误输出流:对外部定义的属性和环境变量的访问:加载 ...
- Java:集合工具类-Collections
Java.util.Collections 集合框架工具类Collections,其方法都是静态的,本身没有构造函数. 常见方法: static <T extends Comparable< ...
- Java从零开始学二十四(集合工具类Collections)
一.Collections简介 在集合的应用开发中,集合的若干接口和若干个子类是最最常使用的,但是在JDK中提供了一种集合操作的工具类 —— Collections,可以直接通过此类方便的操作集合 二 ...
- java之集合工具类Collections
Collections类简介 java.utils.Collections 是集合工具类,用来对集合进行操作.此类完全由在 collection 上进行操作或返回 collection 的静态方法组成 ...
- 吴裕雄--天生自然java开发常用类库学习笔记:集合工具类Collections
import java.util.Collections ; import java.util.List ; import java.util.Set ; public class Collectio ...
- Java笔记(二十四)……集合工具类Collections&Arrays
Collections 集合框架的工具类,方法全部为静态 Collections与Collection的区别 Collection是集合框架的一个顶层接口,里面定义了单列集合的共性方法 Collect ...
- Java常用类(五)之集合工具类Collections
前言 Java提供了一个操作Set.List和Map等集合的工具类:Collections,该工具类提供了大量方法对集合进行排序.查询和修改等操作, 还提供了将集合对象置为不可变.对集合对象实现同步控 ...
- java的集合工具类Collections
集合框架的工具类. Collections:集合框架的工具类.里面定义的都是静态方法. Collections和Collection有什么区别? Collection是集合框架中的一个顶层接口,它里面 ...
- [黑马程序员] 集合框架2——Map系 & 集合工具类(Collections、Arrays)
---------------------- ASP.Net+Android+IO开发..Net培训.期待与您交流! ---------------------- 0. 集合框架按其所实现的接口, 大 ...
随机推荐
- weblogic集群中获取jndi的方式
# The following example specifies a list of WebLogic Servers using the same port: ht.put(Context.PRO ...
- [转载]SharePoint 2013搜索学习笔记之搜索构架简单概述
Sharepoint搜索引擎主要由6种组件构成,他们分别是爬网组件,内容处理组件,分析处理组件,索引组件,查询处理组件,搜索管理组件.可以将这6种组件分别部署到Sharepoint场内的多个服务器上, ...
- Direct3D11学习:(一)开发环境配置
转载请注明出处:http://www.cnblogs.com/Ray1024 从今天开始,开启一个新的系列:Direct3D11的学习教程. 因为一直对3D方面比较感兴趣,最近决定开始学习D3D知 ...
- CSS程序思想
CSS的设计思想,比如:CSS预处理器.CSS对像(OOCSS).SMACSS.Atomic设计和OrganicCSS等 一.CSS预处理器最重要的功能: 1.连接: ...
- 使用WinDbg调试SQL Server查询
上一篇文章我给你介绍了WinDbg的入门,还有你如何能附加到SQL Server.今天的文章,我们继续往前一步,我会向你展示使用WinDbg调试SQL Server查询需要的步骤.听起来很有意思?我们 ...
- ASP.NETC#通用扩展函数之TypeParse 类型转换方便多了
用法: var int1 = "2".TryToInt();//转换为int失败返回0 var int2 = "2x".TryToInt(); var int3 ...
- 使用fat-jar打包多个java工程为可执行文件
对于一个从C++转向Java的程序员来说,制作java的可执行文件,也算是比较棘手的问题.项目是前几个同事留下来的,几个必备的库文件和制作可执行文件的工具居然都是加密未解封的:不知道是不是因为公司和前 ...
- Linux内核知识
版本 linus树 Linux内核最初创始人--Linus Torvalds管理一个Linus树,linus树也称为主线(mainline).一般指的upstream,"上游",也 ...
- mysql-5.6.14-winx64免安装配置
MySQL5.6.11安装步骤(Windows7 64位) 1. 下载MySQL Community Server 5.6.14 2. 解压MySQL压缩包 将以下载的MySQL压缩包解压到自定义目录 ...
- 使用VS2010开发Qt程序的一点经验
导读 相比于Qt Creator,我更喜欢用VS2010来进行开发.虽然启动时间相对较慢,但是VS下强大的快捷键和丰富的插件,以及使用多年的经验,都让我觉得在开发过程中得心应手.其中最重要的一点是,有 ...