黑马程序员_day17 (Collections-sort-max-替换翻转,集合转成数组，增强for循环，可变参数，静态导入)。

---------------------- android培训、java培训 期待与您交流！ ----------------------

一：sort，max，binarySearch。

/*
集合框架的工具类。
Collections:集合框架的工具类。里面定义的都是静态方法。

Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
  它有两个常用的子接口，
  List：对元素都有定义索引。有序的。可以重复元素。
  Set：不可以重复元素。无序。

Collections是集合框架中的一个工具类。该类中的方法都是静态的
  提供的方法中有可以对list集合进行排序，二分查找等方法。
  通常常用的集合都是线程不安全的。因为要提高效率。
  如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

 

*/
import java.util.*;
class  CollectionsDemo
{
 public static void main(String[] args)
 {
  sortDemo();

 }

 

 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,"cc");
  int index = halfSearch2(list,"aaaa",new StrLenComparator());
  sop("index="+index);
 }

 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;
  }
  return -min-1;
 }

 public static int halfSearch2(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);

   int num = cmp.compare(str,key);
   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);
  Collections.sort(list,new StrLenComparator());
  //Collections.swap(list,1,2);
  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;
  if(s1.length()<s2.length())
   return -1;
  return s1.compareTo(s2);
 }
}
/*
class Student
{
}
list.add(new Student());

public static <T extends Comparable<? super T>> void sort(List<T> list)
{
 
}
*/

二：了解Collections中的其他方法。

 

三：Arrays, 数组变集合。

/*
Arrays:用于操作数组的工具类。
里面都是静态方法。

asList:将数组变成list集合
*/

import java.util.*;
class  ArraysDemo
{
 public static void main(String[] args)
 {
//  int[] arr = {2,4,5};
//
//  System.out.println(Arrays.toString(arr));

 

  String[] arr = {"abc","cc","kkkk"};

  //把数组变成list集合有什么好处？
  /*
  可以使用集合的思想和方法来操作数组中的元素。

  注意：将数组变成集合，不可以使用集合的增删方法。
  因为数组的长度是固定。
  contains。
  get
  indexOf()
  subList();

  如果你增删。那么会反生UnsupportedOperationException,

  */
  List<String> list = Arrays.asList(arr);
  //sop("contains:"+list.contains("cc"));
  //list.add("qq");//UnsupportedOperationException,

  //sop(list);

  //int[] nums = {2,4,5};
  Integer[] nums = {2,4,5};

  
  List<Integer> li = Arrays.asList(nums);

 

  /*
  如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
  如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
  */
  sop(li);

 

 }
 public static boolean myContains(String[] arr,String key)
 {
  for(int x=0;x<arr.length; x++)
  {
   if(arr[x].equals(key))
    return true;
  }
  return false;
 }
 
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }

}

四：集合变数组。

/*
集合变数组。
Collection接口中的toArray方法。

*/
import java.util.*;
class  CollectionToArray
{
 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循环

格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
 
}

对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须有被遍历的目标。

建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

*/

import java.util.*;

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,1};

  for(int x=0; x<arr.length; x++)
  {
   System.out.println(arr[x]);
  }
  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版本出现的新特性。

方法的可变参数。
在使用时注意：可变参数一定要定义在参数列表最后面。

*/

class  ParamMethodDemo
{
 public static void main(String[] args)
 {
  //show(3,4);
  /*
  //虽然少定义了多个方法。
  但是每次都要定义一个数组。作为实际参数。

  int[] arr = {3,4};
  show(arr);

  int[] arr1 = {2,3,4,5};
  show(arr1);
  */

  /*
  可变参数。
  其实就是上一种数组参数的简写形式。
  不用每一次都手动的建立数组对象。
  只要将要操作的元素作为参数传递即可。
  隐式将这些参数封装成了数组。

  */
  show("haha",2,3,4,5,6);
  //show(2,3,4,5,6,4,2,35,9,"heh");
  //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 java.util.*;
import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.*;
/*
packa/Demo.class
packb/Demo.class

import packa.*;
import packb.*;
*/

import static  java.lang.System.*;//导入了System类中所有静态成员。

class  StaticImport //extends Object
{
 public static void main(String[] args)
 {

  out.println("haha");
  int[] arr = {3,1,5};

  sort(arr);
  int index = binarySearch(arr,1);
  out.println(Arrays.toString(arr));
  System.out.println("Index="+index);

  ArrayList al = new ArrayList();
  al.add(1);
  al.add(3);
  al.add(2);

  out.println(al);

  sort(al);
  out.println(al);
 }
}

---------------------- android培训、java培训 期待与您交流！ ----------------------