第一 工具类
工具类的Collections和Arrays中的方法全是静态的,下面主要总结几个比较重要的方法。
一、Collections工具类:在Collections工具类中很多方法是用于对集合进行操作的,如比较,查找,随机排序等等
1、查找:
T max(Collection<? extends T> coll) ---> 根据集合的自然顺序,获取coll集合中的最大元素
T max(Collection<? extends T> coll,Comparator<? super T> comp) ---> 根据指定比较器comp的顺序,获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey) ---> 二分法搜索list集合中的指定对象2、替换:
void fill(List<? super T> list, T obj) ---> 将list集合中的全部元素替换成指定对象obj
boolean replaceAll(List<T> lsit,T oldVal,T newVal) ---> 使用newVal替换list集合中的oldVal值
3、排序:
void shuffle(List<?> list) ---> 使用默认随机源对list集合中的元素进行随机排序
void sort(Lsit<T> list) ---> 根据自然顺序对list集合中的元素进行排序
void sort(List<T> lsit,Comparator<? super T> c) ---> 根据指定比较器c的排序方式对list集合进行排序
4、反转
reverse(List<?> list) ---> 反转list集合中元素的顺序
Comparator reverseOrder() ---> 返回一个比较器,强行逆转了实现Comparable接口的对象的自然顺序
Comparator reverseOrder(Comparator<T> cmp) ---> 返回一个比较器,强行逆转了指定比较器的顺序
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
sortDemo();
}
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list,new StrLenComparator());
sop(list);
//int index = Collections.binarySearch(list,"aaaa");
//int index = halfSearch(list,"cc");
int index = halfSearch2(list,"aaaa",new StrLenComparator());
sop("index="+index);
}
public static int halfSearch(List<String> list,String key)
{
int max,min,mid;
max = list.size()-1;
min = 0;
while(min<=max)
{
mid = (max+min)>>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;
}
public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)
{
int max,min,mid;
max = list.size()-1;
min = 0;
while(min<=max)
{
mid = (max+min)>>1;// /2;
String str = list.get(mid);
int num = cmp.compare(str,key);
if(num>0)
max = mid -1;
else if(num<0)
min = mid + 1;
else
return mid;
}
return -min-1;
}
public static void maxDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list);
sop(list);
String max = Collections.max(list/*,new StrLenComparator()*/);
sop("max="+max);
}
public static void sortDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);
//Collections.sort(list);
Collections.sort(list,new StrLenComparator());
//Collections.swap(list,1,2);
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
/*
class Student
{
}
list.add(new Student());
public static <T extends Comparable<? super T>> void sort(List<T> list)
{
}
*/
用collections的fill方法替换掉其中一部分元素:
public class UtilsTest {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("aaaa");
list.add("bbbb");
list.add("ccccc");
list.add("dddddddd");
list.add("eeeee");
list.add("fffff");
System.out.println("开始的:" + list);
fillPart(list, 2, 4, "kkkkk");
}
private static void fillPart(List<String> list, int start, int end,
String str) {
List<String> li = new ArrayList<String>();
for (int i = start; i < end; i++) {
li.add(list.get(i));
list.remove(list.get(i));
}
System.out.println("循环后的:" + list);
Collections.fill(li, str);
list.addAll(start, li);
System.out.println("最后结果的:" + list);
}
}
5、Collections和Collection有什么区别?
Collection是集合框架中的一个顶层接口,它里面定义了单列集合的共性方法。
它有两个常用的子接口,
List:对元素都有定义索引。有序的。可以重复元素。
Set:不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的
提供的方法中有可以对list集合进行排序,二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时,可以通过该工具类中的同步方法,将线程不安全的集合,转换成安全的。
1、Lsit<T> asList(T... a) ---> 将数组转换为集合
注意:将数组转换成集合,不可使用集合的增删方法,因为数组的长度是固定的,如果进行增删操作,则会产生UnsupportedOperationException的编译异常。
a.如果数组中的元素都是对象,则变成集合时,数组中的元素就直接转为集合中的元素
b.如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在
2、binarySearch():查找方法,fill():替换方法,sort():排序方法等
特点:可对数组元素进行相应操作,可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数,且还可以对指定元素的范围,并可根据指定比较器进行相应的操作
如:sort(T[] a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
3、String toString() 可以接收各种数组类型参数,并返回指定数组内容的字符串表现形式
4、集合转为数组
void toString(String[] s) ---> 将集合转为指定数组s,并可通过Arrays.toString(s)获取数组s中的元素
1)指定类型的数组定义的长度:
a.当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组,长度为集合的size
b.当指定类型的数组长度大于了集合的size,就不会创建数组,而是使用传递进来的数组,并且多出的元素的值为null
2)为何将集合转为数组:为了限定对集合中元素的操作,如增删,因为想对创建的集合不做增删方面的操作。
import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
// int[] arr = {2,4,5};
//
// System.out.println(Arrays.toString(arr));
String[] arr = {"abc","cc","kkkk"};
//把数组变成list集合有什么好处?
/*
可以使用集合的思想和方法来操作数组中的元素。
注意:将数组变成集合,不可以使用集合的增删方法。
因为数组的长度是固定。
contains。
get
indexOf()
subList();
如果你增删。那么会反生UnsupportedOperationException,
*/
List<String> list = Arrays.asList(arr);
//sop("contains:"+list.contains("cc"));
//list.add("qq");//UnsupportedOperationException,
//sop(list);
//int[] nums = {2,4,5};
Integer[] nums = {2,4,5};
List<Integer> li = Arrays.asList(nums);
/*
如果数组中的元素都是对象。那么变成集合时,数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
*/
sop(li);
}
public static boolean myContains(String[] arr,String key)
{
for(int x=0;x<arr.length; x++)
{
if(arr[x].equals(key))
return true;
}
return false;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
二 增强for循环
1、格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或数组){执行语句}
2、说明:
1)对集合进行遍历,只能获取集合的元素,但是不能对集合进行操作。
2)迭代器除了遍历外,还可进行remove集合中元素的操作,如果使用ListIterator,还可在遍历过程中,对集合进行增删改查的操作。
3、传统for循环和增强for循环区别:
增强for循环有局限性。必须有被遍历的目标;而传统for循环有索引。所以建议在遍历数组时,使用传统for循环。
/*
* 增强for循环练习
* 格式:for(数据类型 变量名 : 被遍历的集合(Collection)或数组 ){}
* 对集合进行遍历只能获取元素不能操作集合
*
* 一般for和高级for的区别
* 高级for有个极限性必须有被遍历的目标
* 在遍历数组时最好还是可以用一般for,因为可以定义角标,对其进行操作
*/
public class ImproveForTest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(15);
list.add(1);
list.add(8);
method(list);
method_map();
}
private static void method(ArrayList<Integer> list){
for(Integer i : list){
System.out.println(i);
i = 3;//for循环只能遍历集合不能操作集合
}
System.out.println("list:" + list);//for循环只能遍历集合不能操作集合
}
private static void method_map(){
HashMap<Integer,String> hashmap = new HashMap<Integer, String>();
hashmap.put(5, "dad");
hashmap.put(4, "dg");
hashmap.put(2, "hhhhh");
hashmap.put(7, "aaaaaaa");
Set<Integer> keySet = hashmap.keySet();
for(Integer i : keySet){
System.out.println("keysey:" + i + "," + hashmap.get(i));
}
// Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
// for(Map.Entry<Integer,String> me : entrySet)
for(Map.Entry<Integer,String> me : hashmap.entrySet()){
System.out.println("map.entry:" + me.getKey() + "," + me.getValue());
}
}
}
三 可变参数
如果在参数列表中传入多个参数,个数不确定,每次都要复写该方法,可变参数的出现就可以省去复写的麻烦,而直接对数组进行操作
注意:可变参数一定要定义在参数列表的后面。
/*
JDK1.5版本出现的新特性。
方法的可变参数。
在使用时注意:可变参数一定要定义在参数列表最后面。
*/
class ParamMethodDemo
{
public static void main(String[] args)
{
//show(3,4);
/*
//虽然少定义了多个方法。
但是每次都要定义一个数组。作为实际参数。
int[] arr = {3,4};
show(arr);
int[] arr1 = {2,3,4,5};
show(arr1);
*/
/*
可变参数。
其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
*/
show("haha",2,3,4,5,6);
//show(2,3,4,5,6,4,2,35,9,"heh");
//show();
}
public static void show(String str,int... arr)
{
System.out.println(arr.length);
}
/*
public static void show(int[] arr)
{
}
*/
/*
public static void show(int a,int b)
{
System.out.println(a+","+b);
}
public static void show(int a,int b,int c)
{}
*/
}
四 静态导入
静态导入,是将类中的所有静态成员导入进来,但需要注意的是,当导入的两个类中有同名成员时,需要在成员前加上相应的类名。
当类名重名时,需要制定具体的包名;当方法名重名时,制定具体所属的对象或类。
1、import static java.util.Arrays.*; ---> 写入的是Arrays类中的所有静态成员。
2、import static java.lang.System.*; ---> 导入了System类中的所有静态成员
/*
StaticImport 静态导入。
当类名重名时,需要指定具体的包名。
当方法重名是,指定具备所属的对象或者类。
*/
import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.*;
/*
packa/Demo.class
packb/Demo.class
import packa.*;
import packb.*;
*/
import static java.lang.System.*;//导入了System类中所有静态成员。
class StaticImport //extends Object
{
public static void main(String[] args)
{
out.println("haha");
int[] arr = {3,1,5};
sort(arr);
int index = binarySearch(arr,1);
out.println(Arrays.toString(arr));
System.out.println("Index="+index);
ArrayList al = new ArrayList();
al.add(1);
al.add(3);
al.add(2);
out.println(al);
sort(al);
out.println(al);
}
}