------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
黑马程序员 java 基础 毕向东 面向对象 集合框架 工具类 Collections and Arrays
1：集合框架的工具类Collections 的常用方法 binarySearch max sort swap
package day17Collections;
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();
// binarySeacrchDemo();
}
public static <T extends Comparable<? super T>> void sort(List<T> list){
}
static int halfSearch(List<String> l,String key){
int max,min,mid = 0;
max=l.size()-1;
min=0;
while(min<=max){//注意是等于
mid=(min+max)/2;
String str=l.get(mid);
int num=str.compareTo(key);
if(num>0){
max=mid-1;
}else
if(num<0){
min=mid+1;
}else{
return mid;
}
System.out.println(min+"-->"+max);
}
return -min-1;//返回可以插入的位置。从1计数 即：-插入点-1
}
static int halfSearchCompara(List<String> l,String key,Comparator<String> cmp){
int max,min,mid = 0;
max=l.size()-1;
min=0;
while(min<=max){//注意是等于
mid=(min+max)/2;
String str=l.get(mid);
// int num=str.compareTo(key);
int num=cmp.compare(str, key);
if(num>0){
max=mid-1;
}else
if(num<0){
min=mid+1;
}else{
return mid;
}
System.out.println(min+"-->"+max);
}
return -min-1;//返回可以插入的位置。从1计数 即：-插入点-1
}
static void binarySeacrchDemo(){
List<String> l=new ArrayList<String>();
l.add("bb");
l.add("aaa");
l.add("cc");
l.add("ddaaa");
l.add("dd");
Collections.sort(l);
sop(l);
// int indxe=Collections.binarySearch(l, "aaas");
int indxe=halfSearch(l,"aaab");
sop("index ："+indxe);
System.out.println("==============================");
indxe=Collections.binarySearch(l, "bb");
sop("index ："+indxe);
System.out.println("------------------------------");
indxe=Collections.binarySearch(l, "aaa",new ComparaByLength());
sop(""+indxe);
Collections.sort(l,new ComparaByLength());
sop(l);
indxe=halfSearchCompara(l,"aaa",new ComparaByLength());
sop("index ："+indxe);
Collections.sort(l,new ComparaByLength());
sop(l);
indxe=Collections.binarySearch(l, "aaa",new ComparaByLength());
sop(l);
sop("index ："+indxe);
}
static void maxDemo(){
List<String> l=new ArrayList<String>();
l.add("bb");
l.add("aaa");
l.add("cc");
l.add("ddaaa");
l.add("dd");
sop(l);
String a=Collections.max(l,new ComparaByLength());
sop(a);
}
static void sortDemo(){
List<String> l=new ArrayList<String>();
l.add("bb");
l.add("aaa");
l.add("cc");
l.add("ddaaa");
l.add("dd");
sop(l);
Collections.sort(l,new ComparaByLength());
sop(l);
Collections.swap(l, 0, 3);
sop(l);
}
static void sop(Object obj){
System.out.println("->"+obj);
}
}
class ComparaByLength implements Comparator<String>{
public int compare(String o1, String o2) {
return new Integer(o1.length()).compareTo(new Integer(o2.length()));
}
}
2集合框架的工具类Collections 的常用方法 fill
package day17Collections;
/*
* fill(List<E> ,obj)
* 可以讲List集合中的所有元素替换成obj
*
* 联系，将部分元素替换成指定元素*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.TreeSet;
public class CollectionsDemo2 {
public static void main(String[] args) {
List<String> l=new ArrayList<String>();
l.add("bb");
l.add("aaa");
l.add("cc");
l.add("ddaaa");
l.add("dd");
// fillDemo();
// replaceAllDemo();
// orderDemo();
shuffleDemo();
}
static void shuffleDemo(){
List<String> l=new ArrayList<String>();
l.add("bb");
l.add("aaa");
l.add("cc");
l.add("ddaaa");
l.add("dd");
sop(l);
Collections.shuffle(l, new Random());
sop(l);
}
static void orderDemo(){
// TreeSet<String> s=new TreeSet<String>(Collections.reverseOrder());
// TreeSet<String> s=new TreeSet<String>(new ComparaByLength2());
TreeSet<String> s=new TreeSet<String>(Collections.reverseOrder(new ComparaByLength2()));
s.add("abcde");
s.add("aaa");
s.add("kkk");
s.add("ccc");
for (Iterator<String> iterator = s.iterator(); iterator.hasNext();) {
String string =iterator.next();
System.out.println("String:"+string);
}
}
static void replaceAllDemo(){
List<String> l=new ArrayList<String>();
l.add("bb");
l.add("aaa");
l.add("cc");
l.add("ddaaa");
l.add("dd");
Collections.replaceAll(l, "aaa","bbbbb");
sop(l);
Collections.reverse(l);
sop(l);
}
static void fillDemo(){
List<String> l=new ArrayList<String>();
l.add("bb");
l.add("aaa");
l.add("cc");
l.add("ddaaa");
l.add("dd");
Collections.fill(l, "fill");
sop(l);
}
static void sop(Object obj){
System.out.println("->"+obj);
}
}
class ComparaByLength2 implements Comparator<String>{
public int compare(String o1, String o2) {
int num= new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num==0){
return o1.compareTo(o2);
}
return num;
}
}
class StrComparaInTreeSet implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
// return o1.compareTo(o2);
return o2.compareTo(o1);
}
}
3 Arrays 工具 类 ： asList 将数组变成List集合：toString（T [ ]）
package day17Collections;
import java.util.Arrays;
import java.util.List;
public class Arrays_Demo {
/*
* Arrays 工具类
* 都是静态方法
*
* asList 将数组变成List集合
*
* */
public static void main(String[] args) {
int[] arr={1,2,34};
String arrStr=Arrays.toString(arr);
System.out.println(arrStr);
String[] str={"aa","dfa","asdf"};
//把数组变成List集合，
/*可以使用集合的思想和方法
* 进行操作数组中的元素
* */
List<String> lStr=Arrays.asList(str);
System.out.println(lStr.contains("aa"));
// lStr.add("adfafasdfas");
/* java.lang.UnsupportedOperationException
*
* 将数组变成List时，不能使用增加和删除方法
* 将会发生不支持异常*/
System.out.println(lStr);
Integer[] arrNum={1,2,34};
List<Integer> arrStrNum=Arrays.asList(arrNum);
System.out.println(arrStrNum);//[[I@d6132c4]
/*如果数组中的元素是对象，
* 数组中 的元素就直接变成集合中的元素
*如果数组中的元素是基本数据类型，那么该
*数组作为集合的元素
*/
}
}
4 String[] sArr = toArray(new String[ List.size() ]);
package day17Collections;
import java.util.ArrayList;
import java.util.Arrays;
public class Collection_To_Array {
/*
* */
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
al.add("abc1");
// String[] sArr=al.toArray(new String[2]);
// abc1, abc2, abc3, abc1]
String[] sArr=al.toArray(new String[6]);
// abc1, abc2, abc3, abc1, null, null]
System.out.println(Arrays.toString(sArr));
/*1：指定返回类型时到底定义多么长呢
*
* --->当指定类型的长度小于集合 的size（）
* 该集合内部会自动创建一个新的数组
* 长度为集合的size
*
*---> 当指定类型的长度小于集合 的size（）
* 就不会新创建，就使用传递的数组
*
* 所以最后创建new String[list.size()]
*
* 为什么要将集合转变成数组
* 为了限定对元素的操作*/
}
}
5 增强for循环 for（Object obj：？ implement Iterable）
package day17Collections;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/*增强for循环
* 高级for 循环
* for（数据类型 变量名：被遍历的集合或者数组）{
*
* }
* 对集合进行遍历只能获取，不能对 集合进行操作
* 迭代器除了变量还可以进行remove 集合中的元素
*
* 如果使用ListIterator 还可以在变量的过程中
* 进行增删改查
*
* 传统for循环还高级for有什么区别
*
* 高级for循环有一个局限性，必须有变量 的目标
*
* 建议遍历数组的时候使用传统for
* 可以使用角标
* */
public class ForEachDemo {
/**/
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
al.add("abc1");
for (Iterator<String> iterator = al.iterator(); iterator.hasNext();) {
String string = (String) iterator.next();
System.out.println(string);
}
System.out.println("-------");
for(String s : al){
s="kk";//只能取出查看，不能删除修改
System.out.println(s);
}//简化书写
System.out.println(al);
/*public interface Iterable<T>
* 实现这个接口允许对象成为
* "foreach" 语句的目标。
* */
int[] arr={1,3,4,4};
for(int a : arr){
System.out.println(a);
}
System.out.println("for used HashMap");
HashMap<Integer,String> hm=new HashMap<Integer,String> ();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
for(int i:hm.keySet()){
System.out.println("key："+i+":value"+hm.get(i));
}
System.out.println("---Map.entry");
for(Map.Entry<Integer,String> me:hm.entrySet()){
int key=me.getKey();
String value=me.getValue();
System.out.println("key:"+key+":value:"+value);
}
}
}
6 可变参数 T method（T ... t）{ }
package day17Collections;
public class ParamMethodDemo {
/*可以参数
* 实际就是数组参数的简写形式
* 不用每一次都作为参数传递
* 即可
* 隐式的将参数封装成了数组
*
*
* 使用可变参数：
* 将可变参数定义在参数列表的后面
* */
public static void main(String[] args) {
// int[] arr={3,1};
// int[] arr={3,1};
//虽然少定义了方法，但多定义的数组
show(1);
show(1,2,3);
show(1,2,3,4);
}
static void show(int ...arr){
//arr 代表一个数组
for(int i:arr){
System.out.println(i);
}
}
// static void show(int a,int b){
// System.out.println(a+","+b);
// }
// static void show(int a,int b,int c){
// System.out.println(a+","+b+","+c);
// }
}
7静态导入 import static
package day17Collections;
import java.util.Arrays;
import static java.util.Arrays.*;
import static java.lang.System.*;
public class StaticImport {
/*静态导入
* 当类名重复，要指定包名
* 当方法重名是要指定所属的类或者对象
*
*
* import static 意思就是 导入静态的成员*/
public static void main(String[] args) {
int[] arr={8,1,3};
sort(arr);
int index=binarySearch(arr,1);
out.println("index:"+index);
out.println(Arrays.toString(arr));
}
}