package cn.itcast.jdk15;
/*
 
 
 Jdk1.5新特性之-----靜態匯入
 
 靜態匯入的作用：簡化書寫。
 靜態匯入可以作用於一個類的所有成員
 靜態沒匯入的格式：
   import static 包名。類名。靜態成員；
   
   靜態匯入要注意的事項：
   
   1.如果靜態匯入的成員與本類的成員存在同名的情況下，那麼預設使用本類的靜態成員，如果需要指定使用靜態匯入的成員，那麼需要在靜態成員前面加上類名。
 */
/*
import static java.util.Collections.sort;
import static java.util.Collections.binarySearch;
*/
import static java.util.Collections.*;
import static java.lang.System.out;
import java.util.ArrayList;




public class Demo1 {


public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(13);
        list.add(9);
        list.add(10);
        list.add(19);
        //排序
       sort(list);
       out.println("集合的元素："+list);
       out.println("索引值："+binarySearch(list, 13));
       out.println("最大值：："+max(list));

}

public static void sort(ArrayList<Integer> list){
out.println("本類的Sort方法。。。");
}

}

package cn.itcast.jdk15;


import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


/*
 Jdk1.5新特性之----->增強for迴圈 
 增強for迴圈的作用：簡化迭代器的書寫格式(注意增強for迴圈的底層還是使用迭代器遍歷的)
 增強for迴圈的適應範圍：如果是實現了Iterable介面的物件或者是陣列物件都可以使用增強for迴圈
 
 增強for迴圈的格式：
 for（變數型別 變數名：遍歷的目標）
 
 增強for迴圈要注意的事項：
 
 1.注意增強for迴圈的底層還是使用迭代器遍歷獲取的，只不過獲取迭代器由jvm完成的，不需要我們獲取迭代器而已，所有在使用增強for迴圈變數元蘇的過程中，不準使用集合物件對集合的元素個數進行修改。
 2.迭代器遍歷元素與增強for迴圈遍歷元素的區別：使用迭代器遍歷集合的元素時可以刪除集合的元素，而增強for迴圈遍歷元素的過程中，不能呼叫迭代器的remove方法刪除元素
 3.普通for迴圈與增強for迴圈的區別：普通for迴圈可以沒有變數的目標。而增強for迴圈一定要有變數的目標。
 
 */
public class Demo2 {

public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
//新增元素

set.add("狗娃");
set.add("狗剩");
set.add("鐵蛋");

/*
//使用迭代器遍歷Set的集合
Iterator<String> it = set.iterator();
while(it.hasNext()){
it.next();
System.out.println("元素："+);
}
*/

/*
//使用增強For迴圈解決

for(String item:set){
System.out.println("元素："+item);
set.remove("狗剩");
}
*/

int[] arr = {12,5,6,1};

/*
//普通的for迴圈的遍歷格式
for(int i = 0;i<arr.length;i++){
System.out.println("元素："+arr[i]);
}

//使用增強for迴圈實現
for(int item:arr){
System.out.println("元素："+item);
}


//需求：在控制檯列印5句hello world.

for(int i=0;i<5;i++){
System.out.println("hello world");
}
*/



//注意： Map集合沒有實現Iterable介面，所以map集合不能直接使用增強for迴圈，如果需要使用增強for迴圈需要藉助於Collection
// 的集合。
HashMap<String, String> map= new HashMap<String, String>();
map.put("001","張三");
map.put("002","李四");
map.put("003","王五");
map.put("004","趙六");
Set<Map.Entry<String, String>> entrys = map.entrySet();
for(Map.Entry<String, String> entry  :entrys){
System.out.println("鍵："+ entry.getKey()+" 值："+ entry.getValue());
}

}


}

package cn.itcast.jdk15;


import java.util.Iterator;




//自定一個類使用增強for迴圈
class MyList implements Iterable<String>{

Object[] arr = new Object[10];

int index = 0 ; //當前的指標

public void add(Object o){
arr[index++] = o;  // 1
}

public int size(){
return index;
}


@Override
public Iterator<String> iterator() {


return new Iterator<String>() {


int cursor  = 0;


@Override
public boolean hasNext() {
return cursor<index;
}


@Override
public String next() {
return (String) arr[cursor++];
}


@Override
public void remove() {

}
};
}
}


public class Demo3 {


public static void main(String[] args) {
MyList list = new MyList();
list.add("張三");
list.add("李四");
list.add("王五");


for(String item :list){
System.out.println(item);
}
}


}

package cn.itcast.jdk15;
/*
  Jdk1.5新特性之----->可變引數
  需求：定義一個函式做加法功能（）函式做幾個資料的加法功能是不確定的。
  
  可變引數的格式：
  
  資料型別。。。 變數名


 
 可變引數要注意的細節：
 1.如果一個函式的形參使用上了可變引數之後，那麼呼叫該方法的時候可以傳遞引數也可以不傳遞引數。
 2.可變引數實際上是一個數組物件。
 3.可變引數必須位於形參中的最後一個。
 4.一個函式最多隻能有一個可變引數
 
 
 */
public class Demo4 {


public static void main(String[] args) {

int[] arr= {1,2,45,6,7};
/*
System.out.println(arr);

add(arr);
*/
add("haha",1,2,45,6,7);


}


private static void add(String name ,int... arr) {

System.out.println(arr);
System.out.println("長度"+arr.length);
int result = 0;
for(int item : arr){
result+=item;
}
System.out.println("總和："+result);

}


}

package cn.itcast.jdk15;


import java.util.ArrayList;


/*
 Jdk1.5新特性之----->自動裝箱與自動拆箱
 
 Java是面向物件的語言，任何事物都可以使用類進行描述。sun就使用了
 一些Java類描述中八種基本資料型別資料
 
 基本資料型別       包裝型別
 
 byte   Byte
 short   Short
 int     integer
 long    Long
 
 
 float   Float
 double  Double
 
 boolean Boolean
 char    Character
 
 基本資料型別資料 資料有了對應的包裝型別的好處：
 */
public class Demo5 {


public static void main(String[] args) {
String str = "12";
//字串轉成int型別.可以把字串轉換成對應的數字
int i= Integer.parseInt(str);
System.out.println(i);

//把數字轉換成字串
System.out.println("把整數轉換成對應的字串："+Integer.toString(i));

   //把整數轉換成對應的進位制形式
System.out.println("10的二進位制"+Integer.toBinaryString(10));
System.out.println("10的十六進位制"+Integer.toHexString(16));

//可以把字串當成對應的進行資料幫你轉換
String data = "10";
int a = Integer.parseInt(data,11);
System.out.println("a = "+a);

//集合：集合是可以儲存任意物件型別資料的容器
/*ArrayList list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
*/

//自動裝箱：自動把Java的基本資料型別資料轉換成物件型別的資料。
int temp = 10;//基本資料型別
Integer b =temp;//把a儲存的值賦值給b

//Integer b = new Integer(temp);以前的寫法

//自動拆箱：把引用型別的資料轉換成基本資料型別的資料
Integer c= new Integer(13);
int d =c;
//int d =c.intValue();//以前的寫法
System.out.println(d);

//引用的資料型別
Integer e =120;
Integer f =120;
System.out.println("同一個物件麼？"+(e==f));//Integer類內部維護了緩衝陣列，該緩衝陣列儲存的範圍-128~127 這些資料在一個數組中。如果你獲取的資料是落入到這個範圍內，那麼就直接從該緩衝區中獲取對應的資料。

Integer h =128;
Integer w =128;
System.out.println("同一個物件麼？"+(h==w));
}


}

package cn.itcast.jdk15;
/*
 jdk1.5新特性之-----列舉
 
 問題：某些方法所接收的資料必須是在固定範圍之內的， 
 
解決方案： 這時候我們的解決方案就是自定義一個類,然後是私有化建構函式，在自定義類中建立本類的物件對外使用。


jdk1.5對以上問題提出了新的解決方案： 就是使用列舉類解決。


一些方法在執行時，它需要的資料不能是任意的，而必須是一定範圍內的值，Java5以後可以直接使用列舉予以解決。
  比如： 方向 , 性別 、 季節 、 星期......
 
 
 */


/*
//自定義一個性別類
class Gender{

String value;

public static final Gender man = new Gender("男");

public static final Gender woman = new Gender("女");



private Gender(String value) {
this.value = value;
}
}
*/
enum Gender{
man("男"),woman("女");

String value;

private Gender(String value){
this.value = value;
}
}




class Person{

private String name;

private Gender sex;




public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public Gender getSex() {
return sex;
}


public void setSex(Gender sex) {
this.sex = sex;
}
}


public class Demo6 {

public static void main(String[] args) {
Person p = new Person();
p.setName("狗娃");
p.setSex(Gender.woman);
System.out.println("名字："+ p.getName()+" 性別："+ p.getSex().value);

}

}

package cn.itcast.jdk15;


import java.util.Set;


/*
 列舉：一些方法在執行時，它需要的資料不能是任意的，而必須是一定範圍內的值，可以直接使用列舉予以解決
 
 列舉類的定義格式：
    enum 類名{
    
    }
 
 列舉要注意的細節：
   1.列舉也是一個特殊的類
   2.列舉值預設的修飾符都是public static final。
   3.列舉值的資料型別是列舉值所屬的類的資料型別，然後列舉值是指向了本類的物件的。
     public static final Sex man = new Sex();
public static final Sex woman = new Sex();

4.列舉類的構造方法預設的修飾符是private
5.列舉類可以定義自己的成員變數和成員函式
6。列舉類可以自定義建構函式，但是建構函式的修飾符必須是private
7.列舉類可以存在抽象的方法，但是列舉值必須要實現抽象方法
8.列舉值必須要位於列舉類的第一個語句
       
 */


//自定義一個列舉
enum Sex{
man("男"){


@Override
public void run() {
System.out.println("男人在跑。。。。");

}

},woman("女"){


@Override
public void run() {
System.out.println("女人在跑");

}

};//列舉值

String value;//成員變數

//建構函式
private Sex(String value){
this.value = value;
}

//成員函式
public void getValue(){
System.out.println("value："+value);
}

public abstract void run();

}
public class Demo7 {


public static void main(String[] args) {
Sex sex = Sex.man;//獲取到列舉類的物件
sex.value ="男";
sex.getValue();
sex.run();


}


}

package cn.itcast.jdk15;
/*
 
 switch適用的資料型別:byte \ char \ short \int \String \列舉型別
 
 注意：
  case語句後面跟的列舉值，只需要單寫列舉值即可，不需要再宣告該列舉值是屬於哪個列舉類的
 */


//季節列舉類
enum Season{
spring,summer,autumn,winter;
}
public class Demo8 {


public static void main(String[] args) {
Season season = Season.winter;
switch(season){
case spring:
System.out.println("春天");
break;
case summer:
System.out.println("夏天");
break;
case autumn:
System.out.println("秋天");
break;
case winter:
System.out.println("冬天");
break;

}


}


}