黑马程序员_<<Collections,Arrays>>

于 2013-09-28 21:14:00 发布
阅读量110 收藏
点赞数
文章标签： java 移动开发 运维

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------


1.Collections

1.概述

此类时一个工具类，是用来操作集合的。里面有很多方法可以对集合进行更简单的操作，使集合具有一定的特点。

2. 排序

可以利用sort方法对集合进行排序，只能对没有排序功能的集合进行排序，对TreeSet或者TreeMap有自己的排序功能，那么就不需要时用此方法进行排序。

要是使用此方法对集合进行排序，那么集合中的对象必须具有比较性，那么就需要时间接口Comparable，或者是定义比较器实现Compatator接口。

排序的时候，可以按照本身特有的自然排序，也可以自定义比较器来对集合进行设定排序规则。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class CollectionsDemo {
  public static void main(String[] agrs) {
    /* 定义了一个List对象 */
    List<String> list = new ArrayList<String>();
    /*
     * 从String定义的地方已经看出，本身已经实现了Comparable<String>接口此时的比较规则是按照字符的ASCII进行的排序
     * public final class StringextendsObjectimplements Serializable,
     *Comparable<String>, CharSequence
     */
   
    list.add("dkf");
    list.add("abc");
    list.add("zz");
    list.add("qq");
    list.add("e");
    System.out.println("排序前："+list);
    Collections.sort(list);//对集合进行排序,按照默认的排序，ASCII码
    System.out.println("排序后："+list);
  }
}
结果：
排序前：[dkf, abc, zz, qq, e]
排序后：[abc, dkf, e, qq, zz]


我们也可以自定一比较器，进行排序，传入排序中

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class CollectionsDemo {
  public static void main(String[] agrs) {
    /* 定义了一个List对象 */
    List<String> list = new ArrayList<String>();
    /*
     * public static <T>void sort(List<T> list, Comparator<? super T> c)
     * 是此方法指定比较器进行排序按照字符串的长度进行排序
     */
 
    list.add("dkf");
    list.add("abc");
    list.add("zz");
    list.add("qq");
    list.add("e");
    System.out.println("排序前：" + list);
    Collections.sort(list, new MyStringCompartor());// 对集合进行排序,按照比较器进行排序
    System.out.println("排序后：" + list);
  }
}
 
结果：
排序前：[dkf, abc, zz, qq, e]
排序后：[e, zz, qq, dkf, abc]



3. 求最大值

public class CollectionsDemo {
  public static void main(String[] agrs) {
    /* 定义了一个List对象 */
    List<String> list = new ArrayList<String>();
    /*
     * max(Collection<?extends T> coll)方法获得集合中的最大值 max(Collection<? extends
     * T> coll,Comparator<? super T> comp)使用此方法获得按照自己的比较器比较方式获得最大值
     */
 
    list.add("dkf");
    list.add("abcde");
    list.add("zz");
    list.add("qq");
    list.add("e");
    System.out.println("集合：" + list);
    System.out.println("集合中的最大值：" + Collections.max(list));
    System.out.println("按照比较器比较规则的最大值：(长度)："
         + Collections.max(list, new MyStringCompartor()));
  }
}
结果：
集合：[dkf, abcde, zz, qq, e]
集合中的最大值：zz
按照比较器比较规则的最大值：(长度)：abcde


4. 二分查找

在进行二分查找之前，必须对集合对进行排序，只能对排序后的集合进行二分查找才有意义。

如果没有排序，那么也许集合中存在此值，但是查找不到，二分查找会减少查找时间。

public class CollectionsDemo {
  public static void main(String[] agrs) {
    /* 定义了一个List对象 */
    List<String> list = new ArrayList<String>();
    /*
     * binarySearch(List<?extends Comparable<? super T>> list,T key)
     * 对集合中查找指定的值,查找到后返回当前的位置索引，如果没有找到则返回的是要插入的位置(index) –index-1
     */
 
    list.add("dkf");
    list.add("abcde");
    list.add("zz");
    list.add("qq");
    list.add("e");
   
    Collections.sort(list);
    System.out.println("集合：" + list);
    System.out.println("二分查找zz："+Collections.binarySearch(list, "zz"));
  }
}
结果：
集合：[abcde, dkf, e, qq, zz]
二分查找zz：4


模拟二分查找方法

package www.fuxi.jihe;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class CollectionsDemo {
  public static void main(String[] agrs) {
    /* 定义了一个List对象 */
    List<String> list = new ArrayList<String>();
 
    list.add("dkf");
    list.add("abcde");
    list.add("zz");
    list.add("qq");
    list.add("e");
   
    Collections.sort(list);
    System.out.println("集合：" + list);
    System.out.println("二分查找zz："+MySerchBinary(list,"zz"));
    System.out.println("二分查找qq："+MySerchBinary(list,"zz",new MyStringCompartor()));
    System.out.println("OVER");
  }
  /*没有定义比较器*/
  public  static int  MySerchBinary(List<String> list,Stringkey){
    int min=0,max=list.size()-1,m=0;
    while(min<=max){
      m=(min+max)/2;
      int num=list.get(m).compareTo(key);
      if(num>0){
         max=m-1;
      } else if(num<0){
         min=m+1;
      }else{
         return m;
      }
    }
    return -min-1;
  }
  /*定义了自己的比较器的二分查找*/
  public  static int  MySerchBinary(List<String> list,Stringkey,Comparator<String>  com){
    int min=0,max=list.size()-1,m=0;
    while(min<=max){
      m=(min+max)>>1;
      int num=com.compare(list.get(m), key);
      if(num>0){
         max=m-1;
      } else if(num<0){
         min=m+1;
      }else{
         return m;
      }
    }
    return -min-1;
  }
}
结果：
集合：[abcde, dkf, e, qq, zz]
二分查找zz：4
二分查找qq：3
OVER


5. 替换

package www.fuxi.jihe;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class CollectionsDemo {
  public static void main(String[] agrs) {
    /* 定义了一个List对象 */
    List<String> list = new ArrayList<String>();
    list.add("dkf");
    list.add("abcde");
    list.add("zz");
    list.add("edf");
    list.add("asfr");
    Collections.sort(list);
    System.out.println("集合：" + list);
    /*
     * fill(List<? superT> list,T obj)将集合中的所有元素替换成指定元素
     */
    Collections.fill(list, "ss");
    System.out.println("fill后的集合：" + list);
    /*利用自定义的方法把索引从2~4的元素替换成"123"*/
    fillPart(list,"123",2,4);
    System.out.println("部分自定义替换后的集合：" + list);
   
    /* boolean replaceAll(List<T> list, ToldVal,T newVal)
     * 将集合中的所有的某一值替换成指定的值*/
    Collections.replaceAll(list, "ss", "kk");
    System.out.println("replaceAll后的集合：" + list);
  }
 
  /* 替换集合中的部分元素使用fill 从索引start~end 包含start，不包含end*/
  public static  <T> void fillPart(List<?super T> list, T obj, int start, int end) {
          for(int i=start;i<end;i++){
          list.set(i, obj);
          }
  }
 
}
结果：
集合：[abcde, asfr, dkf, edf, zz]
fill后的集合：[ss, ss, ss, ss, ss]
部分自定义替换后的集合：[ss, ss, 123, 123, ss]
replaceAll后的集合：[kk, kk, 123, 123, kk]

6. 反转

1.反转集合中的元素

直接把先有的集合中的元素反转


public class CollectionsDemo {
  public static void main(String[] agrs) {
    /* 定义了一个List对象 */
    List<String> list = new ArrayList<String>();
    list.add("dkf");
    list.add("abcde");
    list.add("zz");
    list.add("edf");
    list.add("asfr");
    Collections.sort(list);
    System.out.println("集合：" + list);
    Collections.reverse(list);//把集合中的元素反转了
    System.out.println("反转后的集合：" + list);
  }
 
}
结果：
集合：[abcde, asfr, dkf, edf, zz]
反转后的集合：[zz, edf, dkf, asfr, abcde]


2. 获得反转比较器

也可以定义一个反转的比较器，这个一般不提倡，所以我们可以获得一个反转比较器，然后在传给集合



/*把字符串按长度比较的比较器*/
public class MyStringCompartor implements Comparator<String> {
 
  public int compare(String o1, String o2) {// 重写此方法
    return o1.length() - o2.length();
  }
 
}
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
 
public class CollectionsDemo {
  public static void main(String[] agrs) {
    /* 定义了一个List对象
     * static <T>Comparator<T> reverseOrder()获得一个反转比较器
     * 重载方法reverseOrder(Comparator<T> cmp)可以把自定义的比较器反转*/
    Set<String> list = new TreeSet<String>(Collections.reverseOrder());
    list.add("de");
    list.add("ab");
    list.add("zz");
    list.add("ee");
    list.add("fr");
    System.out.println("集合：" + list);
    /*把长度比较器反转*/
    Set<String> list1 = new TreeSet<String>(Collections.reverseOrder(new MyStringCompartor()));
    list1.add("de");
    list1.add("a");
    list1.add("zsddz");
    list1.add("eec");
    list1.add("fr");
    System.out.println("集合：" + list1);
  }
 
}
 
结果：
集合：[zz, fr, ee, de, ab]
集合：[zsddz, eec, de, a]

7. 集合线程安全

ArrayList，LinkedList，HashMap,TreeSet，TreeMap都是线程不同步，

Vector，hashtable是线程同步，

那么我们也可以利用工具类把那些线程不同步的集合转换成线程同步，那么就安全了。

Set<T> synchronizedSet(Set<T> s);这个可以将Set集合中线程不同步的集合转换成同步的集合，

swap((List<?>list,inti,intj);方法，替换两个脚表的位置的元素。

shuffle(List<?>list)；按照随机位置重新排序。这个可以用于模拟洗牌，摇骰子

public class CollectionsDemo {
  public static void main(String[] agrs) {
    ArrayList<String> list = new ArrayList<String>();
    list.add("de");
    list.add("ab");
    list.add("zz");
    list.add("ee");
    list.add("fr");
    System.out.println("集合：" + list);
    Collections.shuffle(list);//从新排序
    System.out.println("集合：" + list);
  }
 
}
结果：
集合：[de, ab, zz, ee, fr]
集合：[ee, ab, fr, zz, de]
第二次输出的集合，每次的顺序都是不一样的。


8. Arrays

是用于操作数组用的，

1. 数组转成集合

当数组转成集合后，不能对集合进行删除和添加元素操作，这样会报异常，当数组中存放的对象的话，那么会转换成集合中相应的类型对象，如果集合中存放的是基本数据类型，那么集合中的类型必须是此基本类型的数组类型。

将数组转换成集合，用集合来操作数组更方便，集合中有很多封装方法可以使用，但是转换 成集合后，不支持用集合添加新的对象和删除对象。

如果数组中的元素是基本数据类型，那么要转换成集合的时候，在泛型的类型处写上基本数据数组类型例如List<int []>

package www.fuxi.jihe;
 
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
 
public class ArraysDemo {
  public static void main(String[] args) {
    StringList();
    IntegerList();
    intList();
  }
/*String类型数组转换成集合*/
  public static void StringList() {
    System.out.println("-----------------------");
    String[] srr = { "abc", "def", "123" };
    List<String> list = Arrays.asList(srr);
    Iterator<String> it = list.iterator();
    while (it.hasNext()) {
      System.out.println(it.next());
    }
    System.out.println("-----------------------");
  }
  /*Integer类型数组转换成集合*/
  public static void IntegerList() {
    System.out.println("-----------------------");
    Integer[] sr = { 1, 2, 3 };
    List<Integer> li = Arrays.asList(sr);
    Iterator<Integer> i = li.iterator();
    while (i.hasNext()) {
      System.out.println(i.next());
    }
    System.out.println("-----------------------");
  }
  /*int类型数组转换成集合*/
  public static void intList() {
    System.out.println("-----------------------");
    int[] sr = { 1, 2, 3 };
    List<int[]> li = Arrays.asList(sr);
    Iterator<int[]> i = li.iterator();
    while (i.hasNext()) {
      System.out.println(i.next());
    }
    System.out.println("-----------------------");
  }
 
}
结果：
-----------------------
abc
def
123
-----------------------
-----------------------
1
2
3
-----------------------
-----------------------
[I@79a2e7
-----------------------


2. 集合转成数组

将集合转换成数组的优点：数组长度的确定最好是集合的大小，这样即可以不浪费空间也不会溢出，好处可以限制对集合的操作，这样集合中的元素是安全的，例:文件夹中文件列表的访问。


  import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
 
public class ArraysDemo {
  public static void main(String[] args) {
   
    List<String> list=new ArrayList<String>();
    list.add("abc");
    list.add("123");
    list.add("rfg");
    System.out.println("集合："+list);
    /*
     * 当把集合转换成数组的时候可以使用toArray(),但是数组是Object类型
     * 但是使用其重载方法toArray(T[] a)可以集合转换成相应类型的数组
     *
     * 然后利用工具类的toString()方法将数组转换成字符串输出*/
    String [] str=list.toArray(new String[list.size()]);
   
    System.out.println("数组："+Arrays.toString(str));
  }
 
 
 
}
结果：
集合：[abc, 123, rfg]
数组：[abc, 123, rfg]

3. 增强for循环

增强for循环，对集合的操作只能读取，不能进行删除或者是增加。其实增强for循环底层就是Iterator迭代器

Iterator迭代器对集合操作可以读取和删除

ListIterator迭代器会对集合中的元素进行很多操作，例如增加和删除…等。

package www.fuxi.jihe;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class ArraysDemo {
	public static void main(String[] args) {
		method_1();
		method_2();
		method_3();
	}

	/* 对数组进行高级for循环 */
	public static void method_1() {
		System.out.println("--------\n");
		String[] str = { "abc", "123", "ed3" };
		for (String s : str)
			System.out.println(s);
	}

	/* 对集合中的元素进行读取ArrayList<Integer> */
	public static void method_2() {
		System.out.println("--------\n");
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		for (Integer s : list)
			System.out.println(s);
	}

	/* 对集合HashMap中的进行读取 ，必须对键集进高级for读取，然后获取值 */
	public static void method_3() {
		System.out.println("--------\n");
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("one", 1);
		map.put("tow", 2);
		map.put("three", 3);
		for (String s : map.keySet()) {
			System.out.println(s + ":" + map.get(s));
		}
	}
}
结果：
--------

abc
123
ed3
--------

1
2
3
--------

tow:2
one:1
three:3


4. 可变参数

可变参数利用…表示，其实就是一个可变数组，虚拟机帮我们自动封装，注意事项：可变参数一定要放到参数的最后面。

package www.fuxi.jihe;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
public class ArraysDemo {
  public static void main(String[] args) {
    int sum = sum(2, 3, 4);
    int sum1 = sum(3, 2, 4, 7, 8, 3);
    System.out.println("sum=" + sum);
    System.out.println("sum1=" + sum1);
    show("你好：", "张三", "李四");
  }
 
  /* 可变参数 */
  public static int sum(int... num) {
    int sum = 0;
    for (int n : num)
      sum += n;
    return sum;
  }
 
  public static void show(String str, String... strs) {
    System.out.print(str);
    for (String s : strs)
      System.out.print(s + ",");
  }
 
}
结果：
sum=9
sum1=27
你好：张三,李四,


5. 静态导入

静态导入可以省略类名，但是当有类重复的时候，必须指定包名.类名，当有方法重复的时候，必须指定所属的类。

Import 包名.类名 导入的是包中的类

Import static 包名.类名.*或者是指定 导入的是包中的静态成员

import static java.util.Arrays.*;//导入的是类中的静态成员
 
public class ArraysDemo {
  public static void main(String[] args) {
    String[] strs = { "a", "b", "c" };
    int index = binarySearch(strs, "b");// 这里就可以省略类名了，可以直接写方法当时如果有重名的话，必须指定所属的类
    System.out.println(index);
  }
}
结果：
1
-------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ --------------------

qq_33974741
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值