Collections
集合框架的工具类
着重讲解以下方法：
1、sort()：
1º根据元素的自然顺序对指定列表按升序进行排序，列表中的所有元素都必须实现comparable接口。
public static <T extends Comparable<? super T>> void sort(List<T> list)
2º根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较。
public static <T> void sort(List<T> list, Comparator<? super T> c)
2、max()：
1º根据元素的自然顺序，返回给定collection的最大元素。collection中的所有元素都必须实现comparable接口。
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
2º根据指定比较器产生的顺序，返回给定collection的最大元素。collection中的所有元素都必须可通过指定比较器相互比较。
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
3、binarySearch()：
1º使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过sort(List)方法）。
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
2º使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序（通过sort(List, Comparator) 方法）。
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
示例代码演示上面方法：
/*
集合框架的工具类
Collections：
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List; public class CollectionsDemo { public static void main(String[] args) {
//sortDemo();
//maxDemo();
binarySearchDemo();
} 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, "aaaa");
int index = halfSearch(list, "aaaa", new StrLenComparator()); sop("index = " + index);
} /*
* binarySearch()原理：
* public static <T> int binarySearch
* (List<? extends Comparable<? super T>> list, T key)原理：
*
*/
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;
}
}
//如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点
return -min - 1;
}
/*
* binarySearch()带比较器的原理：
* public static <T> int binarySearch
* (List<? extends T> list, T key, Comparator<? super T> c)
*/
public static int halfSearch(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); //集合中的元素不具备比较性，或者具备的比较性不是我们所需要的，所以应该指定一个Comparator
int num = cmp.compare(str, key);//此时不能调用compareTo()方法 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, new StrLenComparator()); sop(list);
} public static void sop(Object obj) {
System.out.println(obj);
} }
class StrLenComparator 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;
} }
4、fill()：
1º使用指定元素替换指定列表中的所有元素。
public static <T> void fill(List<? super T> list, T obj)
5、replaceAll()：
1º使用另一个值替换列表中出现的所有某一指定值
public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
6、reverse()：
1º反转指定列表中元素的顺序。
public static void reverse(List<?> list)
7、reverseOrder()：
1º返回一个比较器，它强行逆转实现了Comparable接口的对象collection的自然顺序。
public static <T> Comparator<T> reverseOrder()
2º返回一个比较器，它强行逆转指定比较器的顺序。
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
8、shuffle()：
1º使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。
public static void shuffle(List<?> list)
2º使用指定的随机源对指定列表进行置换。所有置换发生的可能性都是相等的，假定随机源是公平的。
public static void shuffle(List<?> list, Random rnd)
示例演示以上方法：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet; class StrComparator implements Comparator<String> { @Override
public int compare(String s1, String s2) {
/*
int num = s1.compareTo(s2);
if(num > 0)
return -1;
if(num < 0)
return 1;
return num;
*/ return s2.compareTo(s1);//反转
} } class StringLenComparator 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;
} }
public class CollectionsDemo1 { public static void main(String[] args) {
//fillDemo();
//replaceAllDemo(); /*
List<String> list = new ArrayList<String>(); list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk"); fillDemo(list, 1, 3, "liayun");
*/ //orderDemo();
shuffleDemo();
} public static void shuffleDemo() {
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.shuffle(list);//使用默认随机源对指定列表进行置换 sop(list);
}
public static void orderDemo() {
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StringLenComparator())); ts.add("abcde");
ts.add("aaa");
ts.add("k");
ts.add("cc"); Iterator<String> it = ts.iterator();
while(it.hasNext()) {
sop(it.next());
}
} public static void replaceAllDemo() {
List<String> list = new ArrayList<String>(); list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk"); sop(list); Collections.replaceAll(list, "aaa", "pp"); sop(list); Collections.reverse(list); sop(list);
}
/*
fill()方法可以将list集合中所有的元素替换成指定元素。
*/
public static void fillDemo() {
List<String> list = new ArrayList<String>(); list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk"); sop(list); Collections.fill(list, "pp"); sop(list);
} //练习：使用fill()，将list集合中部分元素替换成指定元素。
public static void fillDemo(List<String> list, int start, int end, String str) {
for(int i = start; i < end; i++) {
list.set(i, str);
}
sop(list);
} public static void sop(Object obj) {
System.out.println(obj);
} }
Arrays
Arrays：用于操作数组的工具类。里面都是静态方法。
asList：将数组变成list集合。
问：把数组变成list集合有什么好处？
答：可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法(可以使用contains()/get()/indexOf()/subList()等)。 因为数组的长度是固定的。如果你增删，那么会生成UnsupportedOperationException。
- 如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
- 如果数组中的元素都是基本数据类型，那么会将该数组(例：[[I@139a55])作为集合中的元素存在。
示例代码如下：
/*
Arrays：用于操作数组的工具类。
里面都是静态方法。 asList：将数组变成list集合
*/
import java.util.Arrays;
import java.util.List; public class ArraysDemo { public static void main(String[] args) {
//int[] arr = {2, 4, 5};
//System.out.println(Arrays.toString(arr)); String[] arr = {"abc", "cc", "kkk"}; //把数组变成list集合有什么好处？
/*
可以使用集合的思想和方法来操作数组中的元素
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定的。
contains()
get()
indexOf()
subList() 如果你增删，那么会生成UnsupportedOperationException。
*/
List<String> list = Arrays.asList(arr);
//System.out.println("contains:" + list.contains("cc"));
//list.add("qq");//UnsupportedOperationException
//System.out.println(list); int[] nums = {2, 4, 5};
//Integer[] nums = {2, 4, 5}; List<int[]> li = Arrays.asList(nums); /*
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组([[I@139a55])作为集合中的元素存在。
*/
System.out.println(li);
}
}
集合变数组：Collections接口中的toArray()方法。
- 指定类型的数组到底要定义多长呢？当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。当指定类型的数组长度大于了集合的size，那么就不会新创建数组，而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
- 为什么要将集合变数组？为了限定对元素的操作。不需要进行增删了。
示例代码如下：
/*
集合变数组。
Collections接口中的toArray()方法
*/
import java.util.ArrayList;
import java.util.Arrays; public class ArraysDemo1 { public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>(); al.add("abc1");
al.add("abc2");
al.add("abc3"); /*
1、指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于了集合的size，那么就不会新创建数组，而是使用传递进来的数组
所以创建一个刚刚好的数组最优 2、为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。
*/
String[] arr = al.toArray(new String[al.size()]); System.out.println(Arrays.toString(arr));
}
}
高级for循环
格式：
for(数据类型(一般是泛型类型) 变量名 : 被遍历的集合(Collection)或者数组) {
}
对集合进行遍历，只能获取集合中的元素，但是不能对集合进行操作。迭代器除了遍历，还可以进行remove()集合中元素的动作。如果使用ListIterator，还可以在遍历过程中进行对集合进行增删改查的操作。
问：传统for和高级for有什么区别呢？
答：高级for有一个局限性，必须有被遍历的目标。
建议：在遍历数组的时候还是希望使用传统for，因为传统for可以定义角标。
示例代码：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set; public class ForEachDemo { public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>(); al.add("abc1");
al.add("abc2");
al.add("abc3"); for(String s : al) {
s = "kk";
//System.out.println(s);
} System.out.println(al); /*
Iterator<String> it = al.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
*/ int[] arr = {3, 5, 6};
for(int i : arr) {
System.out.println("i:" + i);
} HashMap<Integer, String> hm = new HashMap<Integer, String>();
hm.put(1, "a");
hm.put(2, "b");
hm.put(3, "c"); Set<Integer> keySet = hm.keySet();
for(Integer i : keySet) {
System.out.println(i + "::" + hm.get(i));
} //Set<Map.Entry<Integer, String>> entrySet = hm.entrySet();
//for(Map.Entry<Integer, String> me : entrySet) for(Map.Entry<Integer, String> me : hm.entrySet()) {
System.out.println(me.getKey() + "---------" + me.getValue());
} } }
可变参数
JDK1.5版本出现的新特性。
可变参数：其实就是上一种数组参数的简写形式，不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
方法的可变参数在使用时注意：可变参数一定要定义在参数列表的最后面。
示例代码：
public class ParamMethodDemo {
public static void main(String[] args) {
//show(3, 4);
/*
虽然少定义了多个方法，但是每一次都要定义一个数组，作为实际参数。
int[] arr = {3, 4};
show(arr);
int[] arr1 = {3, 4, 7, 5};
show(arr1);
*/
/*
可变参数
其实就是上一种数组参数的简写形式，不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
*/
show("haha", 2, 3, 4, 5, 6);
//show(2, 3, 4, 5, 6, 4, 2, 35, 9, "heiehi");
//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) {
}
*/
}
静态导入
StaticImport：静态导入。
注意：
- 当类名重名时，需要指定具体的包名。
- 当方法重名时，指定具备所属的对象或类。
示例代码如下：
import static java.util.Arrays.*;//导入的是Arrays类中的所有静态成员。
import java.util.Arrays;
import static java.lang.System.*; //导入了System类中所有静态成员。
public class StaticImport {
public static void main(String[] args) {
out.println("haha");
int[] arr = {3, 1, 5};
sort(arr);
int index = binarySearch(arr, 1);
out.println("index = " + index);
System.out.println(Arrays.toString(arr));//Arrays类中有toString()，Object类中也有toString()，不明确要使用哪个方法。
}
}
Java集合框架(四)的更多相关文章
-
java 集合框架(四)Set
一.概述 Set是一种没有重复元素的集合,它所有的方法都是直接继承自Collection接口,并且添加了一个对重复元素的限制.Set要求强化了equals和hashCode两个方法,以使Set集合可以 ...
-
【集合框架】Java集合框架综述
一.前言 现笔者打算做关于Java集合框架的教程,具体是打算分析Java源码,因为平时在写程序的过程中用Java集合特别频繁,但是对于里面一些具体的原理还没有进行很好的梳理,所以拟从源码的角度去熟悉梳 ...
-
浅谈JAVA集合框架
浅谈JAVA集合框架 Java提供了数种持有对象的方式,包括语言内置的Array,还有就是utilities中提供的容器类(container classes),又称群集类(collection cl ...
-
【JAVA集合框架之Map】
一.概述.1.Map是一种接口,在JAVA集合框架中是以一种非常重要的集合.2.Map一次添加一对元素,所以又称为“双列集合”(Collection一次添加一个元素,所以又称为“单列集合”)3.Map ...
-
【JAVA集合框架之List】
一.List接口概述. List有个很大的特点就是可以操作角标. 下面开始介绍List接口中相对于Collection接口比较特别的方法.在Collection接口中已经介绍的方法此处就不再赘述. 1 ...
-
Java集合框架使用总结
Java集合框架使用总结 前言:本文是对Java集合框架做了一个概括性的解说,目的是对Java集合框架体系有个总体认识,如果你想学习具体的接口和类的使用方法,请参看JavaAPI文档. 一.概述数据结 ...
-
java集合框架之java HashMap代码解析
java集合框架之java HashMap代码解析 文章Java集合框架综述后,具体集合类的代码,首先以既熟悉又陌生的HashMap开始. 源自http://www.codeceo.com/arti ...
-
浅入深出之Java集合框架（上）
Java中的集合框架(上) 由于Java中的集合框架的内容比较多,在这里分为三个部分介绍Java的集合框架,内容是从浅到深,如果已经有java基础的小伙伴可以直接跳到<浅入深出之Java集合框架 ...
-
浅入深出之Java集合框架（中）
Java中的集合框架(中) 由于Java中的集合框架的内容比较多,在这里分为三个部分介绍Java的集合框架,内容是从浅到深,如果已经有java基础的小伙伴可以直接跳到<浅入深出之Java集合框架 ...
随机推荐
-
jsp发布:Could not publish server configuration: null. java.lang.NullPointerException
1.jsp发布: Could not publish server configuration: null. java.lang.NullPointerException
-
跟着鸟哥学Linux系列笔记3-第11章BASH学习
跟着鸟哥学Linux系列笔记0-扫盲之概念 跟着鸟哥学Linux系列笔记0-如何解决问题 跟着鸟哥学Linux系列笔记1 跟着鸟哥学Linux系列笔记2-第10章VIM学习 认识与学习bash 1. ...
-
Java System类
java 不支持 全局方法 和 变量, system 类 中所有成员都是静态的, 而要引用这些变量和方法,可直接system作为前缀,
-
Warning: Cannot modify header information - headers already sent by (output started at
一般来说在header函数前不能输出html内容,类似的还有setcookie() 和 session 函数,这些函数需要在输出流中增加消息头部信息.如果在header()执行之前有echo等语句,当 ...
-
windows驱动程序wdf--KMDF获取应用程序数据缓冲区地址
有3种常用方式:METHOD_BUFFERED METHOD_IN_DIRECT METHOD_OUT_DIRECT 还有METHOD_NEITHER,<windows设备驱动WDF开发 ...
-
SqlSever大数据分页【转】
在sql sever中大数据的分页一直是难以处理的一块,利用id自增列分页也存在不足之处.从一个相对全面的分页看,sql sever2005中新增的row_number()函数解决了这个问题.还 ...
-
第一Sprint阶段对各组提出的意见
组号 组名 意见 1 理财猫 1.界面深色的部分,字体应调成亮色,可以适当美化字体. 2.希望能够自动记录花销,而不是只能手动“记一笔”. 3.功能略少,比如可以添加“收入详情”.“支出详情”. 2 ...
-
[Dart] Flutter开发中的几个常用函数
几个Flutter开发中的常用函数 /** 返回当前时间戳 */ static int currentTimeMillis() { return new DateTime.now().millisec ...
-
TCP/IP、Http、Soap三个基本的通讯协议
看到一个说法,比较通俗易懂: HTTP就是邮局的协议,他们规定了你的信封要怎么写,要贴多少邮票等.... SOAP就是你们之间交流的协议,负责把你所需要表达的意思写在信纸上,同时也负责 ...
-
k8s资源应用的*伸缩Scale（up/down）
伸缩(Scale Up/Down)是指在线增加或减少 Pod 的副本数. 1.增加副本 Deployment nginx-deployment初始是两个副本. [root@k8s-master k ...