Collections：集合框架的工具类
集合框架的工具类：
|--Collections:工具类，里面的方法是静态的。他是对集合进行操作的工具类，他可以对list集合进行排序。
|--Arrays：工具类，对数组进行操作的工具类。
1、Collections工具类
示例代码1：
package Container_expend;reverseOrder用法：
import java.util.*;
public class CollectionsDemo
{
public static void main(String[] args)
{
//sortDemo();
//maxDemo();
//binarySearchDemo();
//fillDemo();
repalceAllDemo();
}
public static void repalceAllDemo()//repalceAllDemo演示
{
List<String> list = new ArrayList<>();
list.add("ab");
list.add("aaaa");
list.add("bb");
list.add("ccccccc");
sop(list);
Collections.replaceAll(list, "bb", "pp");//将List中bb的元素替换成pp
Collections.reverse(list);//反转
sop(list);
}
public static void fillDemo()//fillDemo演示
{
List<String> list = new ArrayList<>();
list.add("ab");
list.add("aaaa");
list.add("bb");
list.add("ccccccc");
sop(list);
Collections.fill(list, "ooo");//将集合中所有元素替换成ooo元素
sop(list);
}
public static void binarySearchDemo()//binarySearch演示
{
List<String> list = new ArrayList<>();
list.add("ab");
list.add("aaaa");
list.add("bb");
list.add("ccccccc");
Collections.sort(list);
sop(list);
int index = Collections.binarySearch(list, "aaaa");
sop("index--"+index);
}
public static void maxDemo()//演示max方法
{
List<String> list = new ArrayList<>();
list.add("ab");
list.add("aaaa");
list.add("bb");
list.add("ccccccc");
String max = Collections.max(list);
sop(max);
}
public static void sortDemo()//演示sort方法,排序的对象必须是可比较的对象
{
List<String> list = new ArrayList<>();
list.add("ab");
list.add("aaaa");
list.add("bb");
list.add("ccccccc");
sop(list);
//Collections.sort(list);//自然排序；注意：不能用于set排序。可以使用比较器
Collections.sort(list,new StrLenComparator());//传入比较器比较
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;
else if(s1.length() < s2.length()) return -1;
else return s1.compareTo(s2);//自然顺序排序
}
}
package Container_expend;
/*
* reverseOrder()可以强行反转比较器。用法：
* Collections.reverseOrder(比较器);示例：Collections.reverseOrder(new StrComparator());
*/
import java.util.*;
class StrComparator implements Comparator<String>//比较器，反转,Collections.reverseOrder()的原理
{
public int compare(String s1,String s2)
{
return s2.compareTo(s1);
}
}
public class OderDemo
{
public static void sop(Object obj)//输出
{
System.out.println(obj);
}
public static void main(String[] args)
{
orderDemo();
}
public static void orderDemo()
{
TreeSet<String> ts = new TreeSet<>(Collections.reverseOrder());//reverseOrder用法
ts.add("aa");
ts.add("asdas");
ts.add("ddd");
ts.add("vv");
ts.add("bbbe");
for(Iterator<String> it = ts.iterator();it.hasNext();)
{
sop(it.next().toString());
}
}
}
练习：
题目：定义一个list集合，用工具类中的方法替换集合中的一部分元素。
分析：
1.将List中一部分元素取出放入一个新的集合内，并移除原集合中这部分元素。
2.用fill方法替换新的集合中的元素。
3.将替换后的集合与之前的集合进行结合。
*/
package Container_expend;
import java.util.*;
/*
题目：定义一个list集合，用工具类中的方法替换集合中的一部分元素。
分析：
1.将List中一部分元素取出放入一个新的集合内，并移除原集合中这部分元素。
2.用fill方法替换新的集合中的元素。
3.将替换后的集合与之前的集合进行结合。
*/
public class fillDemo
{
public static void sop(Object obj)//输出
{
System.out.println(obj);
}
public static void main(String[] args)
{
List<String> list = new ArrayList<>();//泛型定义一个集合
list.add("ab");
list.add("aaaa");
list.add("bb");
list.add("ccccccc");
sop(list);
int start = list.indexOf("aaaa");
int end = list.indexOf("ccccccc");
try
{
fillSome(list,start,end,"replace");
}
catch(InputException e)
{
sop(e.toString());
}
sop(list);
}
public static void fillSome(List<String> list,int start,int end,String s)throws InputException
{
if(start > end) throw new InputException("没有需要替换的元素");//如果输入的开始序号大于结束序号,抛出异常
//定义一个新集合
List<String> li = new ArrayList<>();
//讲要替换的元素存入新集合，并从老集合中移除。
for(int i=start, j=start; j<=end ; j++)//定义i，j。其中i控制替换的元素，j控制循环次数。
{
li.add(list.get(i));//将需要替换的元素放到新集合
list.remove(list.get(i));//移除需要替换的元素
}
Collections.fill(li, s);//替换需要替换的元素
list.addAll(start,li);//将两个集合合并
}
}
//自定义异常
class InputException extends Exception
{
/**
*
*/
private static final long serialVersionUID = 1L;
InputException(String Message)
{
super(Message);
}
}
2、Arrays工具类
集合转数组：
1. 传入的数组的长度最优是多少呢？
* 当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
* 当指定类型的数组长度大于集合的size，那么就不会创建新的数组，而是使用传递进来的数组。
* 所以创建一个长度等于size的数组为最优。
2. 为什么要将集合变成数组？
* 为了限定对元素的操作。
public static void to_Array()//集合转数组
{
ArrayList<String> al = new ArrayList<>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
String [] arr = al.toArray(new String[3]);
sop(Arrays.toString(arr));
}
其他：
package Container_expend;
import java.util.*;
public class ArraysDemo1
{
public static void sop(Object obj)// 输出
{
System.out.println(obj);
}
public static void main(String[] args)
{
//asListDemo();
to_Array();
}
public static void to_String()// 数组转字符串
{
int[] arr ={ 1, 2, 3 };
System.out.println(Arrays.toString(arr));// toString 方法
}
public static void asListDemo()//数组转集合
{
// 将数组转化为集合的好处是：可以用集合的思想和方法操数组元素。
// 注意：将数组转化成的list集合不支持增删元素。如果增删了会出现不支持操作异常。
String[] arr = { "aa", "bb", "cc", "dd" };
List<String> list = Arrays.asList(arr);// 将数组转换成List集合。
sop(list);
// list.add("aaaa");//UnsupportedOperationException
//当整形时候，需要用Integer封装，或者用泛型写。
int [] num = {11,12,13,14};
List<int[]> li_num = Arrays.asList(num);
sop(li_num);//结果为地址[I@263c8db9
Integer [] nums = {1,2,3,4};
List<Integer> li = Arrays.asList(nums);
sop(li);
/*
* 如果数组中的元素都是对象， 那么变成集合时候。数组中的元素直接转成集合中的元素。
* 如果数组中的元素是基本数据类型，那么会将该数组作为集合中的元素存在。
*/
}
//public static void
}
Foreach循环:
高级for循环。
* 格式：
* for(数据类型 变量名:被遍历的数组或集合。)
* {
* }
* 缺陷：只能进行获取元素操作，不能进行其他操作。
* 迭代器：可以进行remove动作。如果使用ListIterator，还可以在操作过程中进行增删改查的操作。
*
* 传统for和高级for的区别？
* 高级for的局限性是：必须有被遍历的目标。
* 建议：在遍历数组时候建议使用传统for，因为传统for可以定于脚标。
public class ForEachDemo
{
public static void sop(Object obj)//输出
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
for(String s:al)
{
sop(s);
}
HashMap<Integer,String> hm = new HashMap<>();
hm.put(1, "aa");
hm.put(2, "bb");
hm.put(3, "cc");
hm.put(4, "dd");
//keyset遍历方式
Set<Integer> keyset = hm.keySet();
for(Integer i : keyset)
{
sop(i+"::"+hm.get(i));
}
//Entry遍历方式
for(Map.Entry<Integer, String> me:hm.entrySet())
{
sop(me.getKey()+"---------"+me.getValue());
}
}
}
可变参数:
* 其实是数组参数的简写形式，不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递就行。
* 隐式将这些元素封装成数组
* 方法的可变参数。在使用的时候注意：可变参数一定要定义在参数列表的最后面
*/
public class paramMethodDemo
{
public static void main(String[] args)
{
show(1,2,3,4);
show(1,2,3);
show("str",1,2,3,4);
}
public static void show(int...arr)//只有一种数据类型
{
System.out.println(arr.length);
}
public static void show(String s,int...arr)//两种数据类型。注意：单一的变量必须放在前面，因为后面的可变参数会将从此处开始往后的所有元素都封装成数组
{
System.out.println(s+"-----"+arr.length);
}
}
静态导入：
* 格式：import static java.util.Arrays;
*
import java.util.*;
import static java.util.Arrays.*;//静态导入
import static java.lang.System.*;
public class StaticImportDemo extends Object//这里先继承Object。即extends Object
{
public static void main(String[] args)
{
int [] arr = {1,2,3};
sort(arr);//因为有静态导入，所有Arrays可以不写。
out.println(Arrays.toString(arr));//这里面的Arrays不能省略，因为Object类中也有一个toString方法
}
}