包装类，泛型，枚举类型

包装类

什么是包装类？如何使用？

包装类是将基本数据类型类型变成引用类型的，其中包含方法可以进行各种数据类型和String类型的相互转换

基本数据类型—>String

String.valueOf(任何类型数据)

String–>基本

基本数据类型 变量 = 基本数据类型的包装类.parseXXXX(String)

特殊: 字符型的包装类是没有parse…–>将字符串–>字符–>用字符串的方法来转

package com.chinasoft.data;

public class IntegerDemo2 {
	public static void main(String[] args) {
		
		String str = "123.1";
		int i  = 10;
		//将整型转换为String
		String str1 = String.valueOf(i);
		//System.out.print(str1);
		//将字符串转化为整型
	   // int j = Integer.parseInt(str);
		double d = Double.parseDouble(str);
	System.out.println(d+1.2);
//		Double dou = 1.23;
		
	//	Float Float = 1.1f;
		
	}
}

可以进行重写相应的方法实现功能（）

Arrays.sort()–对数组进行排序的方法

package com.chinasoft.data;

import java.util.Arrays;
import java.util.Comparator;

public class ArraysDemo {
	public static void main(String[] args) {
		
		Integer[] arr = new Integer[] {3,5,1,2};
        //sort方法第一个存放数组，第二个存放是升序还是降序
		Arrays.sort(arr,
//				new Comparator<Integer>() {
//			
//			@Override
//			public int compare(Integer o1, Integer o2) {
//				return (o1-o2);
//			}
//			
//		}
				//通过a-b升序
                    //b-a降序改变大于小于号，实现顺序排列
				(a,b)->b-a	
		);
		
		
//		int x = 1;
//		 
//		Arrays.sort(arr,(a,b)->a-b);
		
		for(int i : arr) {
			System.out.println(i);
		}


	}
}

//class MyComparator implements Comparator{
//
//	@Override
//	public int compare(Object o1, Object o2) {
//		return (int)o2-(int)o1;
//	}
//	
//}

int-Integer；char-Character；其余的都是将首字母大写如double-Double:

1:手动转换

int i = 100;

1. new Integer(i)–堆

2. Integer.valueOf(i) – 常量池

2:自动转换(自动装箱,自动拆箱)

Integer i = 100;–>虚拟机new or valueOf 自动装箱

package com.chinasoft.data;

public class IntegerDemo {
	public static void main(String[] args) {
		
		Integer i = 100;//自动装箱
		//1: new Integer（超出范围的数字在堆中创建空间存放）
		//2: valueOf--常量池-128 -127
		
		
		int j = i;//自动拆箱
		
		Integer x = -128;
		Integer y = -128;
		
		System.out.println(x==y);
		
		//将对象转换为整形
		Object obj = 1;
		//1) Integer.valueOf(1)---Integer
		//2) Integer--Object
		
//		Integer it = (Integer)obj;
//		int in = it.intValue();
		
		int in = (int)obj;
		
		System.out.println(((int)obj)+2);
		
		
	}
}

泛型

泛型: E -->在编译期指定类型

自定义带泛型的类

class MyTest<E>{
	private E name;

	public E getName() {
		return name;
	}

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

实现泛型

package com.chinasoft;

public class TypeDemo {

	public static void main(String[] args) {
MyTest<Integer> mt = new  MyTest<Integer>();
		
		mt.setName(1);
		
		int x = (int)mt.getName();
		
		System.out.println(x);
	}
}

枚举类型: Enum

枚举类型的定义:

public enum 枚举类型的名字{

​ //枚举的固定的对象

​ 对象(实际参数){ 抽象方法的实现},对象1,…;

​ //上面这些对象的属性和方法

​ 属性;

​ 方法;

​ 抽象方法;

​ 构造方法(参数);–私有的

}

package com.chinasoft;

public enum Week {
	//1:将来这种枚举类型的若干对象
		Mon("星期一",1){

			@Override
			public void work() {
				System.out.println("休息");
			}
			
		},Tue("星期二",2) {
			@Override
			public void work() {
				System.out.println("写代码");
				
			}
		};
		
		private String chinaName;
		private Integer num;
		//抽象方法所有的对象要重写
		public abstract void work();
		
		public void test() {
			System.out.println("xxxx");
		}
		
		public String getChinaName() {
			return chinaName;
		}


		public void setChinaName(String chinaName) {
			this.chinaName = chinaName;
		}


		public Integer getNum() {
			return num;
		}


		public void setNum(Integer num) {
			this.num = num;
		}
		//枚举类型的构造方法必须私有
		private Week(String chinaName,int num){
			this.chinaName = chinaName;
			this.num = num;
		}
}

实现

package com.chinasoft;

public class WeekDemo {
	public static void work(Week week) {
		week.work();
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		Week w1 = Week.Tue;
//		
//		System.out.println(w1.getChinaName());
//		System.out.println(w1.getNum());
//		
//		w1.work();
//		w1.test();
		
		work(Week.Tue);
		

	}

}

switch可以存放byte，short，int，char，枚举类型，字符串类型

		Week week = Week.Mon;
		
		switch(week) {
			case Mon:
				break;
			case Tue:
				break;
		}
		
		String str = "abc";
		
		
		switch(str) {
			case "a":
				break;
			case "abc":
				break;
		}
		
		if(week == Week.Mon) {
			
		}

Math: 数学类:

大部分功能都是Math这个类的静态方法:

   //绝对值
   //int x = Math.abs(-1);

//2的4次方
//double d = Math.pow(2, 4); 
//随机数
	//	double d = Math.random();// 0-1

random()–>返回0-1之间的随机数

产生随机数的方法

package com.chinasoft;

public class MyMath {
	public static int random(int x,int y) {
		return Math.min(x, y)+(int)(Math.random()*(Math.abs(x-y)+1));
	}
}

排除重复的部分

package com.chinasoft;

public class Math2 {

	public static void main(String[] args) {

//		for(int i=0;i<10;i++) {
//			System.out.println(MyMath.random(9, 11));
//		}
		
		//产生x-y之间的随机数(编写方法)
		
		//产生 5 个 7-20之间的不重复的随机数
		
		
		int[] nums = new int[5];
		
		for(int i=0;i<nums.length;i++) {
			nums[i] = MyMath.random(7, 11);
			for(int j=0;j<i;j++) {
				if(nums[j]==nums[i]) {
					i--;
					break;
				}
					
			}
		}
		
		
		for(int i : nums) {
			System.out.println(i);
		}
	}

}