對集合的知識補充，可變引數
阿新 • • 發佈：2018-12-17
import java.util.*; /* * TreeMap使用的注意點： * 1.什麼型別的資料型別可以作為key? * a實現了Comparable介面的CompareTo()方法 * b實現了Comparator介面的Compare()方法 * * JAVA的三種引用引用型別：類，介面，陣列。 * 其中類和陣列的父類都是Object(問了老師，陣列的父類是Object) * 而Object類沒有做a,b處理 * TreeMap新增鍵時呼叫的put方法會去檢測是否做了a,b中的任何一個處理，沒有會有執行時異常 * 可以的代表:String 包裝類,自定義的實現了這兩個介面重寫了相應方法的任意一個的類 * 不可以的代表:沒有做a,b處理的自定義類，陣列，ArrayList和LinkedList * * * 疑問：為什麼HashMap就任何引用型別都可以作為key? * JAVA的三種引用引用型別：類，介面，陣列。 * 其中類和陣列的父類都是Object(問了老師，陣列的父類是Object) * 介面是沒有父類的 * Object類中裡有equals()方法和hashCode()方法的宣告及方法體 * 所以在HashMap裡存物件和陣列是沒有問題的 * * 2.元素可不可以作為key,跟元素內部的元素型別有沒有關係 */ class A{} public class Demo1 { public static void main(String[] args) { TreeMap <char[],String> map=new TreeMap<>(); map.put(new char[] {'d'}, "String"); //在呼叫put方法的時候會報執行時異常，陣列內部沒有實現那兩個介面 TreeMap<A,Integer> map1=new TreeMap<>(); map1.put(new A(),1); //在呼叫put方法的時候會報執行時異常，類A內部沒有實現那兩個接 //2.元素可不可以作為key,跟元素內部的元素型別有沒有關係 TreeMap<Test,String> tree=new TreeMap() ; tree.put(new Test(), "ok"); System.out.println(tree); } } class Test implements Comparable{ Object object = new Object(); @Override public int compareTo(Object o) { return 0; } }
import java.util.*; public class Demo3 { public static void main(String[] args) { /* * 增強for迴圈 * 可以遍歷的內容： * 陣列,Collction---直接遍歷 * Map---間接遍歷 */ /* * 1遍歷陣列,Collction: * for(元素的資料型別 變數:陣列/Collection) * { * 迴圈體 * } */ //遍歷陣列 /* * 原理:當執行增強for迴圈時，會從陣列中自動按順序取值，取出的值放入前面的變數中， * 本次迴圈使用的就是當前的變數 * 結束後，自動開始第二個變數，會自動從陣列中取出第二個變數，再次放入 * 前面的變數中一次進行下去，直到將陣列中的元素取完為止 * 總結：增強for迴圈會自動生成陣列中的每一項將它賦值給指定元素，從而達到遍歷的作用 */ int[] arr=new int[] {4,5,7,8,8}; for(int i:arr){ System.out.println(i); } //對Collection實現類的遍歷 ArrayList<String> list=new ArrayList<>(); list.add("java2"); list.add("java3"); for(String str:list) System.out.println(str); //對Map的遍歷 Map<String,String> map=new HashMap<>(); map.put("01","java"); map.put("04","java3"); map.put("06","java7"); System.out.println(map); //得到set Set<String> set=map.keySet(); //使用增強for迴圈遍歷 for(String key:set) { System.out.println(key+" "+map.get(key)); } } }
import java.util.Arrays;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
/*
* Arrays:陣列工具類，內部封裝了大量運算元組的方法--工具類的方法都是靜態的
*/
//簡單陣列型別轉字串
int[] arr1= {23,4,6,7,8};
System.out.println(arr1.toString());//[[email protected]
//列印的hash碼，雜湊碼通常也成為地址
//因為這個值唯一，但是它其實並不是真正的實體地址
//打印出hash碼值說明陣列並沒有重寫toString方法
//簡單陣列型別轉字串---方便檢視陣列的內容
//內部其實是遍歷了這個陣列，拼接成字串
String s1=Arrays.toString(arr1);
System.out.println(s1);//[23, 4, 6, 7, 8]
//陣列轉集合？---集合的方法多，方便操作
//基本資料型別的陣列轉集合
int[] arr2={23,4,6,7,8};
List<int[]> list=Arrays.asList(arr2);
//返回一個List集合，集合的泛型為int[]，也就是說該List陣列的元素是整型的陣列
System.out.println(list);////[[ public class Demo5 {
//可變引數
//作用：簡化程式碼，方便能操作
//求三個數的和--值傳遞
public static int sum(int a,int b,int c)
{
return a+b+c;
}
//求三個數的和--地址傳遞
public static int sum(int[] a)
{
int sum=0;
for(int i=0;i<=a.length-1;i++)
sum=sum+a[i];
return sum;
}
//通過可變引數求和
//可變引數的格式：資料型別...
//可變引數可以直接理解成一個數組
//int... 等價於int[]
//public static int sum(int... a)系統認為這是和上面的sum名字相同，引數表相同的方法，會編譯異常
public static int sum1(int... a)
{
int sum=0;
for(int i=0;i<=a.length-1;i++)
sum=sum+a[i];
return sum;
}
//public static int sum2(int... a,int b)編譯異常，因為會把傳的引數都存到a裡
public static int sum2(int b,int... a)//
{
int sum=0;
for(int i=0;i<=a.length-1;i++)
sum=sum+a[i];
return sum;
}
//-------------這兩個sum3是過載方法-------------
public static int sum3(int a ,int b)
{
System.out.println("不可變");
return a+b;
}
//當可變引數的方法與不可變引數的方法是過載關係時，呼叫的順序是固定引數的優先於可變引數的
public static int sum3(int...a)
{
System.out.println("可變");
int sum=0;
for(int i=0;i<=a.length-1;i++)
sum=sum+a[i];
return sum;
}
public static void main(String[] args) {
//可變引數：引數的個數可以改變
//求和1:
System.out.println(sum(9,8,2));
int[] arr1= {3,5,7,9};
sum(arr1);
int[] arr2= {3,5,7,9};
sum1(arr2);
//注意點：
//1.給這個可變引數傳值的實參可以直接寫且個數不限制
sum1(35,7,8);//系統自動把數封裝到一個數組，把陣列作為一個引數傳給方法
//2.當包括可變引數在內有多個引數時，可變引數必須寫在引數表的最後，並且一個方法只能有一個可變引數
System.out.println(sum3(3,4));
}
}
import java.util.*;
/*
* Collections：操作類，內部封裝了大量的操作Collections的方法
*/
public class Demo6 {
public static void main(String[] args) {
//要求：儲存多個數據，可重複，能排序
//可以想到的集合：
//1.ArrayList，LinkedList:可重複，不能排序（它的有序只是和新增順序相同）
//2.TreeSet:不可重複，能排序
//這兩個都不符合我們的要求
//這裡使用ArrayList實現可重複，能排序
//即要想實現排序，元素必須實現了Comparable介面的comapreTo()方法
//或Comparator介面的compare()方法
ArrayList<String> list=new ArrayList<>();
list.add("java");
list.add("ios");
list.add("html");
list.add("html");
list.add("BigData");
list.add("python");
list.add("javascripts");
System.out.println("預設的順序:"+list);//預設順序
//升序排序
Collections.sort(list);//String方法已經實現了comapreTo()
//所以這裡直接用就行了
System.out.println("升序排序:"+list);
//按照長短排序
//實現從短到長排序---讓元素(String),實現Comparator介面
//建立比較器物件
ComWithLength comWithLength=new ComWithLength();
Collections.sort(list,comWithLength);//第二個引數為List內元素的比較器
System.out.println("從短到長排"+list);
//實現從長到短排序
//得到一個從長到短的比較器
Comparator<String> comparator1=Collections.reverseOrder(comWithLength);
Collections.sort(list,comparator1);
System.out.println("從長到短排序 "+list);
//字典順序反轉
Comparator<String> comparator2=Collections.reverseOrder();
Collections.sort(list,comparator2);
System.out.println("逆序排序"+list);
//現有順序的反轉
Collections.reverse(list);
System.out.println("現有順序反轉排序"+list);
//求最大值--按照字典排序得到最大值
String max1=Collections.max(list);
System.out.println(max1);
//求最大值---按照字典排序得到的最大值
String max2=Collections.max(list,comWithLength);
System.out.println(max2);
}
}
//建立比較器實現字串從短到長排序
class ComWithLength implements Comparator<String>{
public int compare(String o1,String o2) {
int num=o1.length()-o2.length();
return num;
}
}