黑马程序员--Java面向对象——集合工具类(Collections)
2014-06-25 17:03
417 查看
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流!
面向对象
集合框架的工具类。
Collections:集合框架的工具类。里面定义的都是静态方法。(相信Java的新手们都知道,如果一个类全都是静态方法的话,那么这个类肯定不能创建对象,也不需要给你提供对象的获取方法,因为静态都是优先于对象存在的)
Collections和Collection有什么区别?
Collection是集合框架中的一个顶层接口,它里面定义了单列集合的共性方法。
它有两个常用的子接口,
List:对元素都有定义索引。有序的。可以重复元素。
Set:不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的。
提供的方法中有可以对List集合进行排序,二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时,可以通过该工具类中的同步方法,将线程不安全的集合,转换成安全的。
Collections:静态方法
/*
一个学校,每个学校都有学科,班级的名字就是对应的学科。
对每门学科进行自然排序。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class Test{
public static void main(String[] args){
List<String> list =new ArrayList<String>();
list.add("黑马程序员");
list.add("黑马程序员——云计算");
list.add("黑马程序员——android");
list.add("黑马程序员——.Net");
list.add("黑马程序员——iso");
for(Iterator <String>it = list.iterator();it.hasNext();){
sop(it.next());
}
Collections.sort(list);
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
Collections:静态方法
一个是按照Java指定的比较器进来二分查找,一个是自己指定比较器对集合进行二分查找。
这种思想跟我们之前学数组的时候是一样的,二分查找,所以了解了数组的二分查找,再去看看Java的Src源代码,就基本了解了二分查找的算法,建议使用Java默认的二分查找,因为我们写的不一定比它的效率高。
Collections:静态方法 (排序)(自动反转比较器)(自定义反转比较器)
/*
一个学校,每个学校都有学科,班级的名字就是对应的学科。
对每门学科进行长度排序。从短到长,从长到短。
这时候就可以使用Collections里面的sort方法,并指定比较器进去。
也可以在构造器里面直接比较器进行反转。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.Comparator;
public class Test{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("黑马程序员");
list.add("黑马程序员——云计算");
list.add("黑马程序员——android");
list.add("黑马程序员——.Net");
list.add("黑马程序员——iso");
sop("原集合");
for(Iterator <String>it = list.iterator();it.hasNext();){
sop(it.next());
}
sop("排序后的集合");
Collections.sort(list,new Comparator(){
public int compare(Object obj1,Object obj2){
String s1 = (String)obj1;
String s2 = (String)obj2;
int len = s1.length()-s2.length();
if(len==0)
return s1.compareTo(s2);
return len;
}
});
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
sop("排序后再逆转的集合");
Collections.sort(list,Collections.reverseOrder(new Comparator(){
public int compare(Object obj1,Object obj2){
String s1 = (String)obj1;
String s2 = (String)obj2;
int len = s1.length()-s2.length();
if(len==0)
return s1.compareTo(s2);
return len;
}
}));
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
Collections:静态方法
/*
对List集合的俩个元素进行互换。
并获取集合中元素的最值。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Test{
public static void main(String[] args){
List<Integer>list = new ArrayList<Integer>();
list.add(7);
list.add(1);
list.add(8);
list.add(5);
//打印原集合。
sop(list);
Collections.swap(list,list.indexOf(5),list.indexOf(7));
//打印新集合。
sop(list);
sop("最大值:"+Collections.max(list));
sop("最小值:"+Collections.min(list));
}
public static void sop(Object obj){
System.out.println(obj);
}
}
Collections:静态方法
注意:此方法是替换集合所有元素的值。
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Test{
public static void main(String[] args){
List<Integer>list = new ArrayList<Integer>();
list.add(7);
list.add(1);
list.add(8);
list.add(5);
sop("原集合:"+list);
Collections.shuffle(list);
sop("随机集合:"+list);
Collections.reverse(list);
sop("反转后的集合"+list);
Collections.replaceAll(list,1,2);
//打印出现值被替换后的集合
sop("替换出现值的集合:"+list);
Collections.fill(list,0);
//打印新集合。
sop("统一集合值的集合:"+list);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
同步集合:貌似同步Set集合和同步Map还可以对集合进行有序的排序。
Arrays:用于操作数组的工具类,里面都是静态方法。
数组变成集合(Arrays)
import java.util.Arrays;
import java.util.List;
public class Test{
public static void main(String[] args){
String str [] = {"黑马程序员","CSDN","黑马论坛"};
List<String>list =Arrays.asList(str);
sop(list);
//list.add("新长城");会发生异常。
int arr[] = {1,2,3,4};
List <Integer> list =Arrays.asList(arr);
sop(list);//打印的是哈希值,因为集合把数组中基本数据类型的元素都是当成一个数组存在。
}
public static void sop(Object obj){
System.out.println(obj);
}
}
将数组变成集合,不可以使用集合的增删方法,因为数组的长度是固定的,如果你增删了,会发生不支持操作异常。
如果数组中的元素,都是都像,变成集合时,数组中的元素就直接转换成集合中的元素
如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
集合变成数组
当我们不希望调用者对我们的集合进行操作时,这时候就要把集合变成数组,让操作者不能对其进行基本的操作,但是数组的功能还是可以使用的,比如获取。
import java.util.List;
import java.util.ArrayList;
public class Test{
public static void main(String[] args){
List<String>list =new ArrayList<String>();
list.add("黑马程序员");
list.add("CSDN");
list.add("黑马论坛");
Object[] arr = list.toArray();
for(int x=0;x<arr.length;x++){
System.out.print(arr[x]);
}
}
}
指定类型的数组到底要定义多长呢?
当指定类型的数组长度小于了集合的size,那么该方法内部都会创建一个新的数组,长度为集合的size
当指定类型的数组长度大于了集合的size,就不会新创建数组,而是使用传递进来的数组,
所以应该创建一个刚刚好的。
String[] arr = list.toArray(new String[al.size()]);
为什么要将集合变数组?
为了限定对元素的操作。不需要进行增删。
集合(增强for循环)
1.5JDK的新特性
高级 for 循环(简化书写)
格式:
for(数据类型 变量名 : 被变量的集合(Collection)或者数组){
}
对集合进行遍历,只能获取集合元素,但是不能对集合进行操作。
迭代器出了遍历,还可以进行remove集合中元素的动作。
如若果使用ListIterator,还可以在遍历过程中对集合进行增删改查动作。
传统for和高级for有什么区别呢?
高级for有一个局限性,必须有便利的目标
建议在遍历数组的时候,还是希望使用传统for,因为传统for可以定义脚标。
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test{
public static void main(String[] args){
List<String>list = new ArrayList<String>();
list.add("黑马程序员");
list.add("CSDN");
list.add("黑马论坛");
sop("高级for循环遍历list");
for(String s:list){
sop(s);
}
Map<Integer,String>map
= new HashMap<Integer,String>();
map.put(1,"黑马程序员——张三");
map.put(2,"黑马程序员——李四");
map.put(3,"黑马程序员——王五");
map.put(4,"黑马程序员——赵六");
Set<Integer>keySet = map.keySet();
sop("高级for循环遍历第一种获取方式map获取键,用键获取map值");
for(Integer i :keySet){
sop(i+","+map.get(i));
}
Set<Map.Entry<Integer,String>>entrySet = map.entrySet();
sop("高级for循环遍历第二种获取方式map的键和值");
for(Map.Entry<Integer,String> me : entrySet){
sop(me.getKey()+","+me.getValue());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
集合(可变参数)
JDK 1.5 版本出现的新特性
方法的可变参数(简化书写)
注意:可变参数一定要定义在函数参数的末尾,另外是三个点不是二个。
比如要调用一个函数,传入的参数格式类型,一样,但是个数不一样,普通方式是重载,很麻烦。
所以应该传入一个数组,但是自己定义一个数组也麻烦,所以Java有了这种函数参数定义方法接收。
public class Test{
public static void main(String... args){
int sum = method(1,2,3,4,5);
int num = method(1,2,3,4,5,6,7,8,9,10);
System.out.println(sum);
System.out.println(num);
}
public static int method(int ...arr){
int sum =0;
for(int i : arr)
sum+=i;
return sum;
}
}
可变数组,其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象,只要将操作的元素作为参数传递即可,
隐式将这些参数封装成数组,可以传入空参数,0长度数组。
集合(静态导入)
JDK 1.5 版本出现的新特性
StaticImport 集合(静态导入) (简化书写)
当类名重名时,需要指定具体的包名。
当方法重名是,指定具备所属的对象或者类。
import static java.util.Arrays.*;//导入Arrays类中的所有静态成员。
public class Test{
public static void main(String...
args){
int []arr = {1,7,3,5,2};
for(int i:arr){
System.out.print(i);
}
System.out.println();
sort(arr);//由于该方法是静态的,而Arrays里面的静态成员全部导入进来了,就可以省略类名.调用。
for(int i:arr){
System.out.print(i);
}
}
}
面向对象
集合框架的工具类。
Collections:集合框架的工具类。里面定义的都是静态方法。(相信Java的新手们都知道,如果一个类全都是静态方法的话,那么这个类肯定不能创建对象,也不需要给你提供对象的获取方法,因为静态都是优先于对象存在的)
Collections和Collection有什么区别?
Collection是集合框架中的一个顶层接口,它里面定义了单列集合的共性方法。
它有两个常用的子接口,
List:对元素都有定义索引。有序的。可以重复元素。
Set:不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的。
提供的方法中有可以对List集合进行排序,二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时,可以通过该工具类中的同步方法,将线程不安全的集合,转换成安全的。
Collections:静态方法
static
| sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。 |
一个学校,每个学校都有学科,班级的名字就是对应的学科。
对每门学科进行自然排序。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class Test{
public static void main(String[] args){
List<String> list =new ArrayList<String>();
list.add("黑马程序员");
list.add("黑马程序员——云计算");
list.add("黑马程序员——android");
list.add("黑马程序员——.Net");
list.add("黑马程序员——iso");
for(Iterator <String>it = list.iterator();it.hasNext();){
sop(it.next());
}
Collections.sort(list);
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
Collections:静态方法
static
| binarySearch(List<? extendsComparable<? super T>> list, T key) 使用二分搜索法搜索指定列表,以获得指定对象。 | |
static
| binarySearch(List<? extends T> list, T key,Comparator<? super T> c) 使用二分搜索法搜索指定列表,以获得指定对象。 |
这种思想跟我们之前学数组的时候是一样的,二分查找,所以了解了数组的二分查找,再去看看Java的Src源代码,就基本了解了二分查找的算法,建议使用Java默认的二分查找,因为我们写的不一定比它的效率高。
Collections:静态方法 (排序)(自动反转比较器)(自定义反转比较器)
static
| sort(List<T> list,Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。 |
static
| sort(List<T> list,Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。 |
static
| reverseOrder() 返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 | |
static
| reverseOrder(Comparator<T> cmp) 返回一个比较器,它强行逆转指定比较器的顺序。 |
一个学校,每个学校都有学科,班级的名字就是对应的学科。
对每门学科进行长度排序。从短到长,从长到短。
这时候就可以使用Collections里面的sort方法,并指定比较器进去。
也可以在构造器里面直接比较器进行反转。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.Comparator;
public class Test{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("黑马程序员");
list.add("黑马程序员——云计算");
list.add("黑马程序员——android");
list.add("黑马程序员——.Net");
list.add("黑马程序员——iso");
sop("原集合");
for(Iterator <String>it = list.iterator();it.hasNext();){
sop(it.next());
}
sop("排序后的集合");
Collections.sort(list,new Comparator(){
public int compare(Object obj1,Object obj2){
String s1 = (String)obj1;
String s2 = (String)obj2;
int len = s1.length()-s2.length();
if(len==0)
return s1.compareTo(s2);
return len;
}
});
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
sop("排序后再逆转的集合");
Collections.sort(list,Collections.reverseOrder(new Comparator(){
public int compare(Object obj1,Object obj2){
String s1 = (String)obj1;
String s2 = (String)obj2;
int len = s1.length()-s2.length();
if(len==0)
return s1.compareTo(s2);
return len;
}
}));
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
Collections:静态方法
static void | swap(List<?> list, int i, int j) 在指定列表的指定位置处交换元素。 |
对List集合的俩个元素进行互换。
并获取集合中元素的最值。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Test{
public static void main(String[] args){
List<Integer>list = new ArrayList<Integer>();
list.add(7);
list.add(1);
list.add(8);
list.add(5);
//打印原集合。
sop(list);
Collections.swap(list,list.indexOf(5),list.indexOf(7));
//打印新集合。
sop(list);
sop("最大值:"+Collections.max(list));
sop("最小值:"+Collections.min(list));
}
public static void sop(Object obj){
System.out.println(obj);
}
}
Collections:静态方法
static
| fill(List<? super T> list, T obj) 使用指定元素替换指定列表中的所有元素。 |
static void | reverse(List<?> list) 反转指定列表中元素的顺序。 |
static
| replaceAll(List<T> list, T oldVal, T newVal) 使用另一个值替换列表中出现的所有某一指定值。 |
static void | shuffle(List<?> list) 使用默认随机源对指定列表进行置换。 |
static void | shuffle(List<?> list, Random rnd) 使用指定的随机源对指定列表进行置换。 |
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Test{
public static void main(String[] args){
List<Integer>list = new ArrayList<Integer>();
list.add(7);
list.add(1);
list.add(8);
list.add(5);
sop("原集合:"+list);
Collections.shuffle(list);
sop("随机集合:"+list);
Collections.reverse(list);
sop("反转后的集合"+list);
Collections.replaceAll(list,1,2);
//打印出现值被替换后的集合
sop("替换出现值的集合:"+list);
Collections.fill(list,0);
//打印新集合。
sop("统一集合值的集合:"+list);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
同步集合:貌似同步Set集合和同步Map还可以对集合进行有序的排序。
static
| synchronizedCollection(Collection<T> c) 返回指定 collection 支持的同步(线程安全的)collection。 | |
static
| synchronizedList(List<T> list) 返回指定列表支持的同步(线程安全的)列表。 | |
static
| synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步(线程安全的)映射。 | |
static
| synchronizedSet(Set<T> s) 返回指定 set 支持的同步(线程安全的)set。 | |
static
| synchronizedSortedMap(SortedMap<K,V> m) 返回指定有序映射支持的同步(线程安全的)有序映射。 | |
static
| synchronizedSortedSet(SortedSet<T> s) 返回指定有序 set 支持的同步(线程安全的)有序 set。 |
static
| asList(T... a) 返回一个受指定数组支持的固定大小的列表。 | |
static int | binarySearch(byte[] a, byte key) 使用二分搜索法来搜索指定的 byte 型数组,以获得指定的值。 |
static boolean[] | copyOf(boolean[] original, int newLength) 复制指定的数组,截取或用 false 填充(如有必要),以使副本具有指定的长度。 |
static boolean[] | copyOfRange(boolean[] original, int from, int to) 将指定数组的指定范围复制到一个新数组。 |
static void | sort(byte[] a) 对指定的 byte 型数组按数字升序进行排序。 |
static String | toString(boolean[] a) 返回指定数组内容的字符串表示形式。 |
import java.util.Arrays;
import java.util.List;
public class Test{
public static void main(String[] args){
String str [] = {"黑马程序员","CSDN","黑马论坛"};
List<String>list =Arrays.asList(str);
sop(list);
//list.add("新长城");会发生异常。
int arr[] = {1,2,3,4};
List <Integer> list =Arrays.asList(arr);
sop(list);//打印的是哈希值,因为集合把数组中基本数据类型的元素都是当成一个数组存在。
}
public static void sop(Object obj){
System.out.println(obj);
}
}
将数组变成集合,不可以使用集合的增删方法,因为数组的长度是固定的,如果你增删了,会发生不支持操作异常。
如果数组中的元素,都是都像,变成集合时,数组中的元素就直接转换成集合中的元素
如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
集合变成数组
当我们不希望调用者对我们的集合进行操作时,这时候就要把集合变成数组,让操作者不能对其进行基本的操作,但是数组的功能还是可以使用的,比如获取。
Object[] | toArray() 返回包含此 collection 中所有元素的数组。 | |
| toArray(T[] a) 返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。 |
import java.util.ArrayList;
public class Test{
public static void main(String[] args){
List<String>list =new ArrayList<String>();
list.add("黑马程序员");
list.add("CSDN");
list.add("黑马论坛");
Object[] arr = list.toArray();
for(int x=0;x<arr.length;x++){
System.out.print(arr[x]);
}
}
}
指定类型的数组到底要定义多长呢?
当指定类型的数组长度小于了集合的size,那么该方法内部都会创建一个新的数组,长度为集合的size
当指定类型的数组长度大于了集合的size,就不会新创建数组,而是使用传递进来的数组,
所以应该创建一个刚刚好的。
String[] arr = list.toArray(new String[al.size()]);
为什么要将集合变数组?
为了限定对元素的操作。不需要进行增删。
集合(增强for循环)
1.5JDK的新特性
高级 for 循环(简化书写)
格式:
for(数据类型 变量名 : 被变量的集合(Collection)或者数组){
}
对集合进行遍历,只能获取集合元素,但是不能对集合进行操作。
迭代器出了遍历,还可以进行remove集合中元素的动作。
如若果使用ListIterator,还可以在遍历过程中对集合进行增删改查动作。
传统for和高级for有什么区别呢?
高级for有一个局限性,必须有便利的目标
建议在遍历数组的时候,还是希望使用传统for,因为传统for可以定义脚标。
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test{
public static void main(String[] args){
List<String>list = new ArrayList<String>();
list.add("黑马程序员");
list.add("CSDN");
list.add("黑马论坛");
sop("高级for循环遍历list");
for(String s:list){
sop(s);
}
Map<Integer,String>map
= new HashMap<Integer,String>();
map.put(1,"黑马程序员——张三");
map.put(2,"黑马程序员——李四");
map.put(3,"黑马程序员——王五");
map.put(4,"黑马程序员——赵六");
Set<Integer>keySet = map.keySet();
sop("高级for循环遍历第一种获取方式map获取键,用键获取map值");
for(Integer i :keySet){
sop(i+","+map.get(i));
}
Set<Map.Entry<Integer,String>>entrySet = map.entrySet();
sop("高级for循环遍历第二种获取方式map的键和值");
for(Map.Entry<Integer,String> me : entrySet){
sop(me.getKey()+","+me.getValue());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
集合(可变参数)
JDK 1.5 版本出现的新特性
方法的可变参数(简化书写)
注意:可变参数一定要定义在函数参数的末尾,另外是三个点不是二个。
比如要调用一个函数,传入的参数格式类型,一样,但是个数不一样,普通方式是重载,很麻烦。
所以应该传入一个数组,但是自己定义一个数组也麻烦,所以Java有了这种函数参数定义方法接收。
public class Test{
public static void main(String... args){
int sum = method(1,2,3,4,5);
int num = method(1,2,3,4,5,6,7,8,9,10);
System.out.println(sum);
System.out.println(num);
}
public static int method(int ...arr){
int sum =0;
for(int i : arr)
sum+=i;
return sum;
}
}
可变数组,其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象,只要将操作的元素作为参数传递即可,
隐式将这些参数封装成数组,可以传入空参数,0长度数组。
集合(静态导入)
JDK 1.5 版本出现的新特性
StaticImport 集合(静态导入) (简化书写)
当类名重名时,需要指定具体的包名。
当方法重名是,指定具备所属的对象或者类。
import static java.util.Arrays.*;//导入Arrays类中的所有静态成员。
public class Test{
public static void main(String...
args){
int []arr = {1,7,3,5,2};
for(int i:arr){
System.out.print(i);
}
System.out.println();
sort(arr);//由于该方法是静态的,而Arrays里面的静态成员全部导入进来了,就可以省略类名.调用。
for(int i:arr){
System.out.print(i);
}
}
}
相关文章推荐
- 黑马程序员——Java基础——集合框架工具类(Collections类和Arrays类)
- Java面向对象——集合工具类(Collections)
- 黑马程序员_java集合(2) 泛型&数组与集合工具类
- 黑马程序员——Java基础---泛型、集合框架工具类:collections和Arrays
- 黑马程序员 java 基础 毕向东 面向对象 集合框架 工具类 Collections and Arrays
- Bag集合工具类(apache-commons-collections3.2工具包)在java中的使用
- 黑马程序员——Java基础--集合框架工具类:Collections、Arrays、其他对象
- 黑马程序员-JAVA基础-Java 集合之Collections 工具类
- 黑马程序员--Java面向对象——集合框架(Map)
- 黑马程序员---------Java面向对象——集合
- [Google Guava] 2.3-强大的集合工具类:java.util.Collections中未包含的集合工具
- 黑马程序员——面向对象的集合框架(java)
- 黑马程序员_Java第17天知识总结_集合框架的工具类_Collections_Arrays_将数组变成list集合_集合变数组_高级for循环_可变参数
- 黑马程序员-java基础之集合Map集合,Collections,Arrays工具类
- java的集合框架工具类(黑马程序员)
- 黑马程序员_毕向东JAVA基础_集合(3)Map&Collections&Arrays&增强for循环
- 黑马程序员 Java面向对象——集合框架(Map)
- 黑马程序员 Java面向对象——集合框架总结
- 黑马程序员——JAVA基础之Collections和Arrays,数组集合的转换
- 黑马程序员—java基础学习--Map集合、Collections,Arrays工具类