utilities
|--Collections
|--Arrays
*13-常用对象API(集合框架-工具类-Collections-排序)
允许重复、按某个规则顺序输出。
Collections——工具类
Collection——接口
// T temp = list.get(i);
// list.set(i, list.get(j));
// list.set(j, temp);
Collections.swap(list, i, j);
*14-常用对象API(集合框架-工具类-Collections-折半&最值)
*16-常用对象API(集合框架-工具类-Collections-其他方法&将非同步集合转成同步集合的方法)
自己实现:
封装:
其他:
replaceall(List,T old,T new)
怎么实现的呢?
*16-常用对象API(集合框架-工具类-Collections-其他方法&将非同步集合转成同步集合的方法)
枚举----ArrayListm 相互转换、
ArrayList:多线程,如何加锁同步。
List list = new ArrayList();//非同步的。
list = MyCollections.synList(list);//返回一个同步的list.
给非同步的集合加锁。
class MyCollections{
public static List synList(List list){
return new MyList(list);
}
private class MyList implements List{
private List list;
private static final Object lock = new Object();
MyList(List list){
this.list = list;
}
public boolean add(Object obj){
synchronized(lock)
{
return list.add(obj);
}
}
public boolean remove(Object obj){
synchronized(lock)
{
return list.remove(obj);
}
}
}
}
-----------------------小结-------------------------
package cn.itcast.p2.toolclass.collections.demo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
import cn.itcast.p2.comparator.ComparatorByLength;
public class CollectionsDemo {
/**
* @param args
*/
public static void main(String[] args) {
/*
* Collections:是集合框架的工具类。
* 里面的方法都是静态的。
*
*
*/
demo_4();
}
public static void demo_4() {
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("zhangsan");
list.add("zhaoliu");
list.add("xiaoqiang");
System.out.println(list);
// Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");
Collections.shuffle(list);
// Collections.fill(list, "cc");
System.out.println(list);
}
public static void demo_3() {
/*
TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){
@Override
public int compare(String o1, String o2) {
int temp = o2.compareTo(o1);
return temp;
}
});
*/
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));
ts.add("abc");
ts.add("hahaha");
ts.add("zzz");
ts.add("aa");
ts.add("cba");
System.out.println(ts);
}
public static void demo_2(){
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
// Collections.sort(list);
System.out.println(list);
// int index = Collections.binarySearch(list, "cba");
// System.out.println("index="+index);
//获取最大值。
String max = Collections.max(list,new ComparatorByLength());
System.out.println("max="+max);
}
public static void demo_1(){
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);
//对list集合进行指定顺序的排序。
// Collections.sort(list);
// mySort(list);
// mySort(list,new ComparatorByLength());
Collections.sort(list,new ComparatorByLength());
System.out.println(list);
}
public static <T> void mySort(List<T> list,Comparator<? super T> comp){
for (int i = 0; i < list.size()-1; i++) {
for (int j = i+1; j < list.size(); j++) {
if(comp.compare(list.get(i), list.get(j))>0){
// T temp = list.get(i);
// list.set(i, list.get(j));
// list.set(j, temp);
Collections.swap(list, i, j);
}
}
}
}
public static <T extends Comparable<? super T>> void mySort(List<T> list){
for (int i = 0; i < list.size()-1; i++) {
for (int j = i+1; j < list.size(); j++) {
if(list.get(i).compareTo(list.get(j))>0){
// T temp = list.get(i);
// list.set(i, list.get(j));
// list.set(j, temp);
Collections.swap(list, i, j);
}
}
}
}
}
*17-常用对象API(集合框架-工具类-Arrays-方法介绍)
//toString的经典实现。
public static String myToString(int[] a){
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {//中间省略条件判断,提高了效率。
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
*18-常用对象API(集合框架-工具类-Arrays-asList方法)
数组转集合。为什么?集合的方法多!
为什么只有一个元素呢?
-------------------------小结-------------------------
package cn.itcast.p3.toolclass.arrays.demo;
import java.util.Arrays;
import java.util.List;
//数组转成集合。
public class ArraysDemo {
/**
* @param args
*/
public static void main(String[] args) {
/*
* Arrays:集合框架的工具类。里面的方法都是静态的。
*
*/
// int[] arr = {3,1,5,6,3,6};
// System.out.println(Arrays.toString(arr));
demo_2();
}
public static void demo_2() {
/*
* 如果数组中的元素是对象,那么转成集合时,直接将数组中的元素作为集合中的元素进行集合存储。
*
* 如果数组中的元素是基本类型数值,那么会将该数组作为集合中的元素进行存储。
*
*/
int[] arr = {31,11,51,61};
List<int[]> list = Arrays.asList(arr);
System.out.println(list);
}
/**
*
*/
public static void demo_1() {
/*
* 重点:List asList(数组)将数组转成集合。
*
* 好处:其实可以使用集合的方法操作数组中的元素。
* 注意:数组的长度是固定的,所以对于集合的增删方法是不可以使用的
* 否则会发生UnsupportedOperationException
*
*
*/
String[] arr = {"abc","haha","xixi"};
boolean b = myContains(arr, "xixi");
System.out.println("contains:"+b);
List<String> list = Arrays.asList(arr);
boolean b1 = list.contains("xixi");
System.out.println("list contaisn:="+b1);
// list.add("hiahia");//UnsupportedOperationException
System.out.println(list);
}
public static boolean myContains(String[] arr,String key){
for (int i = 0; i < arr.length; i++) {
if(arr[i].equals(key))
return true;
}
return false;
}
//toString的经典实现。
public static String myToString(int[] a){
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {//中间省略条件判断,提高了效率。
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
}
*19-常用对象API(集合框架-工具类-Collection-toArray方法)
集合转数组,
集合为什么变数组——可以对集合中的元素,操作的方法进行限定。不允许对其进行增删。
package cn.itcast.p3.toolclass.arrays.demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ToArray {
public static void main(String[] args) {
/*
* 集合转成数组呢?
*
* 使用的就是Collection接口中的toArray方法。
*
* 集合转成数组:可以对集合中的元素操作的方法进行限定。不允许对其进行增删。
*
*
*/
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
/*
* toArray方法需要传入一个指定类型的数组。
* 长度该如何定义呢?
* 如果长度小于集合的size,那么该方法会创建一个同类型并和集合相同size的数组。
* 如果长度大于集合的size,那么该方法就会使用指定的数组,存储集合中的元素,其他位置默认为null。
*
* 所以建议,最后长度就指定为,集合的size。
*/
String[] arr = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arr));
}
}
*20-常用对象API(集合框架-JDK5.0特性-ForEach循环)
/*
* foreach语句:
* 格式:
* for(类型 变量 :Collection集合|数组)
* {
*
* }
*
* 传统for和高级for的区别?
* 传统for可以完成对语句执行很多次,因为可以定义控制循环的增量和条件。
*
* 高级for是一种简化形式。
* 它必须有被遍历的目标。该目标要是数组,要么是Collection单列集合。
*
* 对数数组的遍历如果仅仅是获取数组中的元素,可以使用高级for。
* 如果要对数组的角标进行操作建议使用传统for。
*
*/
只用于遍历
package cn.itcast.p4.news.demo;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ForEachDemo {
/**
* @param args
*/
public static void main(String[] args) {
/*
* foreach语句:
* 格式:
* for(类型 变量 :Collection集合|数组)
* {
*
* }
*
* 传统for和高级for的区别?
* 传统for可以完成对语句执行很多次,因为可以定义控制循环的增量和条件。
*
* 高级for是一种简化形式。
* 它必须有被遍历的目标。该目标要是数组,要么是Collection单列集合。
*
* 对数数组的遍历如果仅仅是获取数组中的元素,可以使用高级for。
* 如果要对数组的角标进行操作建议使用传统for。
*
*/
List<String> list =new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
for(String s : list){ //简化书写。
System.out.println(s);
}
int[] arr = {3,1,5,7,4};
for(int i : arr){
System.out.println(i);
}
//可以使用高级for遍历map集合吗?不能直接用,但是可以将map转成单列的set,就可以用了。
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(3,"zhagsan");
map.put(1,"wangyi");
map.put(7,"wagnwu");
map.put(4,"zhagsansan");
for(Integer key : map.keySet()){
String value = map.get(key);
System.out.println(key+"::"+value);
}
for(Map.Entry<Integer,String> me : map.entrySet()){
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key+":"+value);
}
// Iterator<String> it = list.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
}
}
*21-常用对象API(集合框架-JDK5.0特性-函数可变参数)
可变参数:创建数组、传递参数,自动将这些数字转化为数组。
局限性:
package cn.itcast.p4.news.demo;
public class ParamterDemo {
/**
* @param args
*/
public static void main(String[] args) {
// int sum = add(4,5);
// System.out.println("sum="+sum);
// int sum1 = add(4,5,6);
// System.out.println("sum1="+sum1);
// int[] arr = {5,1,4,7,3};
// int sum = add(arr);
// System.out.println("sum="+sum);
// int[] arr1 = {5,1,4,7,3,9,8,7,6};
// int sum1 = add(arr1);
// System.out.println("sum1="+sum1);
int sum = newAdd(5,1,4,7,3);
System.out.println("sum="+sum);
int sum1 = newAdd(5,1,2,7,3,9,8,7,6);
System.out.println("sum1="+sum1);
}
/*
* 函数的可变参数。
* 其实就是一个数组,但是接收的是数组的元素。
* 自动将这些元素封装成数组。简化了调用者的书写。
*
* 注意:可变参数类型,必须定义在参数列表的结尾。
*
*/
public static int newAdd(int a,int... arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
// System.out.println(arr);
// return 0;
}
public static int add(int[] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
public static int add(int a,int b){
return a+b;
}
public static int add(int a,int b,int c){
return a+b+c;
}
}
*22-常用对象API(集合框架-JDK5.0特性-静态导入)
package cn.itcast.p4.news.demo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static java.util.Collections.*;//静态导入,其实到入的是类中的静态成员。
//import static java.util.Collections.max;//静态导入,其实到入的是类中的静态成员。
import static java.lang.System.*;
public class StaticImportDemo {
/**
* @param args
*/
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc3");
list.add("abc7");
list.add("abc1");
out.println(list);
sort(list);
System.out.println(list);
String max = max(list);
System.out.println("max="+max);
}
}