集合框架知识梳理3
---------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------
1、高级for循环: foreach 有一个局限性 必须有被遍历的目标。
1、高级for循环: foreach 有一个局限性 必须有被遍历的目标。
建议在遍历数组的时候,还是希望使用传统for 因为传统for可以定义角标。
2、可变参数
在使用时注意:可变参数一定要定义在参数列表的最后面。
3、数组变集合 List<String> list = Arrays.asList(str);
3、数组变集合 List<String> list = Arrays.asList(str);
使用集合的思想和方法来操作数组中的元素。
4、将数组变成集合,不可以使用集合的增删方法。因为数组的长度是固定的
5、集合变数组 String [] str = list.toArray(new String[list.size()]);
5、集合变数组 String [] str = list.toArray(new String[list.size()]);
直接把集合的长度给出。
6、快速查看数组中元素,使用:Arrays.toString
7、Collection.reverseOrder() 反转 重点掌握
7、Collection.reverseOrder() 反转 重点掌握
1、反转比较器 Collections.reverseOrder(new StrLenCom()
2、默认反转 Collections.reverseOrder()
8、二分法查找,又称拆半查找
BinarySearch
通常运用在:前提必须是有序列表,且变动不大经常查找的时候。
9、静态导入 StaticImport
当类名重名时,需要指定具体的包命,
当方法重名时,需要指定具备所属对象或者类。
import java.util.*;// 不加Static 导入的是类。import static java.util.Arrays.*;// import 后面加static 导入的是【Arrays类中】所有静态成员import static java.lang.System.*;//导入的是【System类中】所有静态成员
-------------------------------------------------------
【5】
数组变集合
Arrays : 用于操作数组的工具类。
里面都是静态。很多方法和Collections雷同。
重点:
asList : 将数组 变成list集合。 可以使用集合的思想和方法来操作数组中的元素。
注意: 将数组变成集合,不可以使用集合的增删方法。因为数组的长度是固定的
可以用:contains、get、indexOf、subList
都可以用,就是不可以用增删。
一旦使用增删 就会报UnsupportedoperationExcepton错误
class ArraysDemo6 {
public static void main(String[] args) {
int [] ch = {2,3,5};
System.out.println(Arrays.toString(ch));
String [] str = {"fdsfs","fds","gr"};
//为什么要这么写,有什么好处,我们都知道数组是查看是否包含某一个元素
//我们必须要遍历数组,然后写判断,而这样进行转换后,
//我们可以直接使用contains进行判断。
//可以使用集合的思想和方法来操作数组中的元素。
//注意: 将数组变成集合,不可以使用集合的增删方法。因为数组的长度是固定的
List<String> list = Arrays.asList(str);
System.out.println(list);
System.out.println("是否包含某一元素"+list.contains("gr"));
//list.add("ss");//UnsupportedoperationExcepton 不支持的操作异常。为什么呢
int [] ints = {2,3,5};
//如何加泛型。
//List li7 = Arrays.asList(ints); //aa
List <int []>li =Arrays.asList(ints);//bb
//aa 和bb 的区别
//如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素
//如果数组中的元素都是基本数据类型,那么会将【该数组】作为集合中的元素存在。
System.out.println(li);
//System.out.println(li7);
Integer [] in = {2,3,5};
//List li2 = Arrays.asList(in);
List<Integer> li2 = Arrays.asList(in);
//这个时候 数组就是对象,所以数组中的元素直接变成了集合中的元素。
System.out.println(li2);
}
}
【6】
集合变数组:
Collection 接口中的toArray方法。
2个方法:
toArray()
Arrays.toString()
class CollectionToArray7{
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("dsa");
list.add("ssa");
list.add("dhffa");
//如何快速查看数组中元素,Arrays.toString 派上用场了。
String [] art = new String[3];
list.toArray(art);
System.out.println(Arrays.toString(art));
//两种方式是一样的。
//String [] str = list.toArray(new String [4]);//【a】
//发现这个下标,给元素个数没有关系。
//1、指定类型的数组,到底要定义多长呢?
// 1-1、当指定类型的数组长度小于了集合的size,该方法内部会创建一个新的数组,
// 长度为集合的size. (所以写4的时候,会多出一个null)
// 1-2、当指定类型的数组长度大于集合的size,就不会创建新的数组,而是使用传递进来的数组(追加在后面。)
//
// 所以创建一个刚刚好的数组,最优。
// 所以/【a】应该写成:
//2、为什么要把集合变数组?
// 1、为了限定对元素的操作。不需要增删。
String [] str = list.toArray(new String[list.size()]);//直接把集合的长度给出。
System.out.println(Arrays.toString(str));
}
}
【7】
BinarySearch 原理。
二分法查找,又称拆半查找
通常运用在:前提必须是有序列表,且变动不大经常查找的时候。
通过把有序列表一分为二,使用有序列表的kay 进行中间值的比较,
来进行左右某一边进行查找,速度很快,不宜增删。
class BinarySearchTest2 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("bb");
list.add("hhhhh");
list.add("a");
list.add("fffs");
list.add("mm");
list.add("zzzzz");
//Collections.sort(list);
System.out.println(list);
//int num = balfSearch(list,"aaa");
Collections.sort(list,new MyCom());
System.out.println(list);
int num = balfSearchII(list,"aaa",new MyCom());
System.out.println(num);
}
public static int balfSearch(List<String> list, String key){
int max,min,mid;
max=list.size()-1;//最大值为长度-1
min=0;
while(min<=max){ //循环条件
mid=(max+min)>>1; // 同 /2 中间值 为最大最小值和除以2.
String str=list.get(mid);// 获取中间值
int num = key.compareTo(str);//用key和中间值进行比较。 具备性,默认比较方法。
if(num<0){
max=mid-1;// key没有中间值大,就在左边查询,所以最大值就是中间值-1
}
else if(num>0){
min=mid+1;// key比中间值大,在右边查询,所以最小值为中间值+1
}else{
return mid;//相等就是中间值。
}
}
return -min-1;// 没有就是负数,专业写法,负的插入点-1.
}
//【当元素不具备比较性时,该如何处理:】
// 在参数中加上 Comparator比较器,在比较时调用compare方法,如果需要新的比较方式,
// 实现Comparator接口并覆盖compare方法即可
public static int balfSearchII(List<String> list, String key,Comparator<String> com){
int max,min,mid;
max=list.size()-1;
min=0;
while(min<=max){
mid=(max+min)>>1;
String str=list.get(mid);
//int num = key.compareTo(str);//用key和中间值进行比较。 具备性,默认比较方法。
int num =com.compare(key,str);//【在此处调用compare方法进行2个参数的传递即可】
if(num<0){
max=mid-1;
}
else if(num>0){
min=mid+1;
}else{
return mid;
}
}
return -min-1;
}
}
//自定义比较器。 按照长度排序
class MyCom implements Comparator<String>{
public int compare(String s1,String s2){
if(s1.length()>s2.length()){
return 1;
}else if(s1.length()==s2.length()){
return s1.compareTo(s2);
}
return -1;
}
}
【8】
collections 工具类
常见方法:
sort(List<T> list) :排序
max(Collection<? extends T> coll) :最大值
fill(List<? super T> list, T obj) :用指定元素替换掉列表中的所有元素
binarySearch(List<? extends Comparable<? super T>> list, T key) :但凡使用该方法,必须是有序集合(list) 返回负数,表示不存在。
replaceAll(List<T> list, T oldVal, T newVal) :使用一个新值替换掉一个旧的值
reverse(List<?> list) :反转集合
reverseOrder() :强行逆转比较器顺序
Collections 中重点方法:
1、Collection.reverseOrder() 反转
通常默认排序,需要反转的时候,需要编写一个比较器来完成。而Collection.reverseOrder() 能强行进行反转,并能对比较器强行反转
class CollectionsDemo5{
public static void main(String[] args) {
orderDemo();
System.out.println("-------------------------------");
frequecyDemo();
System.out.println("-------------------------------");
copyDemo();
System.out.println("-------------------------------");
addAllDemo();
System.out.println("-------------------------------");
List list=new ArrayList();
synchronizedListDemo(list);
System.out.println("-------------------------------");
shuffleDemo();
}
//随机排序 //扑克牌,骰子。
public static void shuffleDemo(){
System.out.println("随机排序");
List<String> list = new ArrayList<String>();
list.add("a");
list.add("ag");
list.add("dfd");
list.add("ggggs");
list.add("a");
list.add("dd");
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
}
//只需要传入一个集合工具类,或者直接对比较器进行强转即可。
public static void orderDemo(){
System.out.println("新值替换旧值,反转");
TreeSet<String> list = new TreeSet<String>(); //默认排序
//TreeSet<String> list = new TreeSet<String>(Collections.reverseOrder());//对默认排序反转
//TreeSet<String> list = new TreeSet<String>(new StrLenCom()); //传入比较器 长度排序
TreeSet<String> list = new TreeSet<String>(Collections.reverseOrder(new StrLenCom())); //对 长度排序进行反转
//新增元素。
list.add("a");
list.add("ag");
list.add("dfd");
list.add("ggggs");
list.add("z");
list.add("dd");
for(Iterator<String> it = list.iterator() ; it.hasNext() ; ){
System.out.println(it.next());
}
}
//返回一个安全(同步)的list集合
public static List synchronizedListDemo(List list){
list = Collections.synchronizedList(new ArrayList());
Collections.addAll(list,"dd","a","ccc","mmmm");
synchronized(list) {
Iterator i = list.iterator(); // Must be in synchronized block
while (i.hasNext())
System.out.println(i.next());
return list;
}
//来进行安全转换
//System.out.println(list);
}
//查找只等值的个数
public static void frequecyDemo(){
System.out.println("查找只等值的个数");
List<String> list = new ArrayList<String>();
list.add("a");
list.add("ag");
list.add("dfd");
list.add("ggggs");
list.add("a");
list.add("dd");
System.out.println(list);
int num=Collections.frequency(list,"a");
System.out.println(num);
}
//全部加入
public static void addAllDemo(){
List<String> list = new ArrayList<String>();
Collections.addAll(list,"dddd","mm");
System.out.println(list);
}
public static void copyDemo(){
System.out.println("查找只等值的个数");
List<String> list = new ArrayList<String>();
list.add("a");
list.add("ag");
list.add("dfd");
list.add("ggggs");
list.add("a");
list.add("dd");
System.out.println(list);
//List<String> clist = new ArrayList<String>();
//想要进行copy 必须要加入一个相同长度。
//Collections.addAll(clist, new String[list.size()]);
//Collections.copy(clist,list);
List<String> clist=list;//这种方式和copy 有何区别?
System.out.println(clist);
System.out.println(list);
}
}
//1
class StrLenCom implements Comparator<String>{
public int compare(String s1,String s2){
//return s2.compareTo(s1);
if(s1.length()>s2.length()){
return 1;
}
if(s1.length()==s2.length()){
return s1.compareTo(s2);
}
return -1;
}
}
//2
class MyCom implements Comparator<String>{
public int compare(String s1,String s2){
return s2.compareTo(s1);
}
}
【9】
高级for循环: foreach
格式:
【 for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)】
1/集合只能是Collection集合。2/这个数据类型 是 集合或者数组中元素的类型。
(如果不确定元素类型,就写Object, 1.5 后出了泛型,一般都带泛型)
for
只能对元素进行取出,而不能做修改动作:
对集合进行遍历,只能获取集合元素,但是不能对集合进行操作。
迭代器 除了遍历,还可以进行remove 集合中的元素。
如果使用listIterator 还可以在遍历过程中对集合进行增删改查的动作
底层原理还是 迭代器,升级后 优化简写了。
传统for循环和高级for 有什么区别呢。
1、高级for 有一个局限性。 必须有被遍历的目标。
建议: 在遍历数组的时候,还是希望使用传统for 因为传统for可以定义角标。
JDK 1.5 版本出现的新特性。
可变参数
在使用时注意:可变参数一定要定义在参数列表的最后面。
JDK 1.5 版本出现的新特性。
StaticImport : 静态导入。
当类名重名时,需要指定具体的包命,
当方法重名时,需要指定具备所属对象或者类。
只能对元素进行取出,而不能做修改动作:
对集合进行遍历,只能获取集合元素,但是不能对集合进行操作。
迭代器 除了遍历,还可以进行remove 集合中的元素。
如果使用listIterator 还可以在遍历过程中对集合进行增删改查的动作
底层原理还是 迭代器,升级后 优化简写了。
传统for循环和高级for 有什么区别呢。
1、高级for 有一个局限性。 必须有被遍历的目标。
建议: 在遍历数组的时候,还是希望使用传统for 因为传统for可以定义角标。
class foreachDemo8 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("dsa");
list.add("ssa");
list.add("dhffa");
//【增强型 For 循环】
for(String s : list){
System.out.println(s);
}
//迭代器取出
//for(Iterator<String> it = list.iterator() ; it.hasNext() ; ){
// System.out.println(it.next());
//}
//数组:
String [] ss=new String[100];
int [] arr = {2,23,58,26,17};
for(int i : arr){
System.out.println(i);
}
// 哈哈, 高级for 打印100次
for(String s : new String[10]){
s="hello word";
System.out.println(s);
}
int m = 1;
for(int in : new int[10]){
in=m++;
System.out.println(in);
}
HashMap<Integer,String> hm= new HashMap<Integer,String>();
hm.put(123,"tt");
hm.put(3,"tt");
hm.put(1,"tt");
hm.put(353,"pp");
//1、for里面只能是Collection,所以mapd 类型需要转变
// 所以Set 来装该集合的key值
// 通过遍历获取key的时候,来获取value值。
Set<Integer> keyset = hm.keySet();
//1、
for(Integer i : keyset ){
String s =hm.get(i);
System.out.println(i+".."+s);
}
System.out.println("...................");
//2、
//Set<Map.Entry<Integer,String>> entryset = hm.entrySet();
//for(Map.Entry<Integer,String> me: entryset){
//【简写为:
for(Map.Entry<Integer,String> me: hm.entrySet()){
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key+".."+value);
}
}
}
【10】
JDK 1.5 版本出现的新特性。
可变参数
在使用时注意:可变参数一定要定义在参数列表的最后面。
class ParamMethodDemo9{
public static void main(String[] args) {
show(2,3);
//2 可是当我们需要4,5,6个的时候,那岂不是要重载很多个方法?
//3-2 发现比1 重载方式好,但是每一次使用都要先创建数组,麻烦
int [] arr = {2,3,4,};
show1(arr);
int [] arr1 = {2,3,4,4,5,6,7,8};
show1(arr1);
//4-2 发现用【...】代表可变参数跟3比,相当于替换了[]号,其实就是2的简写。
show2(2,3);
show2(2,3,4);
show2(2,3,4,4,5,6,7,8);
show3("hh",2,3);//编译通过
//show4(2,3,"aaa");//编译失败
}
//1-1 当我们做2个数运算时候 ,定义一个接收2个参数方法即可
public static void show(int a ,int b){
sop(a+b);
}
//1-2当我们做3个数运算时候 ,重载1方法即可。
public static void show(int a ,int b,int c){
sop(a+b+c);
}
//3-1 这个时候我们想到了定义参数为数组,
public static void show1(int [] arr){
//用循环来计算
int num=0;
for(int i =0;i<arr.length;i++){
num+=arr[i];
}
sop(num);
}
//4-1
public static void show2(int ... arr){
//用高级for来计算
int num = 0;
for(int i : arr){
num+=i;
}
sop(num);
}
//4-2 【注意事项 可变参数一定放最后】
public static void show3(String str,int ... arr){}//编译通过
//4-3
//public static void show4(int ... arr,String str){}//编译错误
public static void sop(Object obj){
System.out.println(obj);
}
}
【11】
JDK 1.5 版本出现的新特性。
StaticImport : 静态导入。
当类名重名时,需要指定具体的包命,
当方法重名时,需要指定具备所属对象或者类。
import java.util.*;// 不加Static 导入的是类。
import static ava.util.Arrays.*;// import 后面加static 导入的是【Arrays类中】所有静态成员
import static java.lang.System.*;//导入的是【System类中】所有静态成员
class StaticImport91 {
public static void main(String[] args) {
//Static System 静态导入后 :
out.println("!!!静态导入后的输出语句");
int [] arr = {2,3,1};
//Arrays.sort(arr);//排序
sort(arr);
//int index = Arrays.binarySearch(arr,2);//使用二分法查找。查找前必须排序
int index = binarySearch(arr,2);//使用二分法查找。查找前必须排序
out.println(Arrays.toString(arr));//转成集合【AAA】
//System.out.println(Arrays.toString(arr));//转成集合【AAA】
System.out.println("Index:"+index);//
//1、发现每次都要写Arrays 或者Collections 等非常麻烦。
// 所以我们可以导入包,来简写。静态包的导入
// 2、静态导入Arrays 后发现,可以直接调用方法了。简单了很多
// 3、为什么【AAA】不简写 因为类都是Object 中有toString,而Object是所有类的超类。
// 如果这时候去掉Arrays 指定不明确,编译失败。
// 3-1、当类名重名时,需要指定具体的包命,
// 3-2、当方法重名时,需要指定具备所属对象或者类。
// 4、静态导入System后,可以去掉System了。
}
}
---------------------------------------------------------------------------------------------------------------------------------------------
----------
android培训、
java培训、期待与您交流!----------