Java--基础语法--02

7 泛型

7.1 应用1：确定集合元素类型

泛型的好处：

1.将运行时的异常提前至了编译时。
2.避免了无谓的强制类型转换 。

泛型在集合中的常见应用：

ArrayList<String> list = new ArrayList<String>();  //true  推荐使用。
ArrayList<Object> list = new ArrayList<String>();  //false
ArrayList<String> list = new ArrayList<Object>();  //false

以下两种写法主要是为了兼顾新老系统的兼用性问题。

ArrayList<String> list = new ArrayList();  true   
ArrayList list = new ArrayList<String>();  true

注意：泛型没有多态的概念，左右两边的数据类型必须要一致，或者只是写一边的泛型类型，推荐两边都写泛型。

public class test {
    public static void main(String[] args) {
        ArrayList<String>  list = new ArrayList<String>();  //<String> 表示该容器只能存储字符串类型的数据。
        list.add("aa");
        list.add("bb");
        list.add("cc");
        for(int i = 0 ; i < list.size() ; i++){
            String str =  list.get(i);
            System.out.println("大写："+ str.toUpperCase());
        }
    }
}

7.2 应用2：接收自定义泛型类型的参数

定义一个方法可以接收任意类型的参数，而且返回值类型必须要与实参的类型一致。 自定义泛型：自定义泛型就是一个数据类型的占位符或者是一个数据类型的变量。 方法上自定义泛型：

修饰符  <声明自定义的泛型>返回值类型  函数名(使用自定义泛型 ...){

}

在泛型中不能使用基本数据类型，如果需要使用基本数据类型，那么就使用基本数据类型对应的包装类型。

基本数据类型 –> 包装类型 byte –> Byte short –> Short int –> Integer long –>
Long double –> Double float –> Float boolean –> Boolean char –>
Character

方法泛型注意事项：

在方法上自定义泛型，这个自定义泛型的具体数据类型是在调用该方法的时候传入实参时确定具体的数据类型的。
自定义泛型只要符合标识符的命名规则即可，但是自定义泛型我们一般都习惯使用一个大写字母表示。（T Type、E Element）

public class test {
    public static void main(String[] args) {
        String str = getData("abc");
        Integer i = getData(123);
    }
    public static <T>T getData(T para){
        return para;
    }
}

7.3 应用3：泛型类

泛型类的定义格式：

class 类名<声明自定义泛型>{

}

泛型类注意事项：

1.在类上自定义泛型的具体数据类型是在使用该类的时候创建对象时候确定的。
2.如果一个类在类上已经声明了自定义泛型，如果使用该类创建对象的时候没有指定泛型的具体数据类型，那么默认为Object类型
3.在类上自定义泛型不能作用于静态的方法，如果静态的方法需要使用自定义泛型，那么需要在方法上自己声明使用。

class MyArrays<T>{
    //元素翻转
    public void reverse(T[] arr){
        for(int startIndex = 0, endIndex = arr.length-1 ; startIndex<endIndex ; startIndex++,endIndex--){
            T temp  = arr[startIndex];
            arr[startIndex] = arr[endIndex];
            arr[endIndex] = temp;
        }
    }
    public String toString(T[] arr){
        StringBuilder sb = new StringBuilder();
        for(int i = 0 ; i < arr.length ; i++){
            if(i==0){
                sb.append("["+arr[i]+",");
            }else if(i==arr.length-1){
                sb.append(arr[i]+"]");
            }else{
                sb.append(arr[i]+",");
            }
        }
        return sb.toString();
    }
    public static <T>void print(T[] t){}
}
public class test {
    public static void main(String[] args) {
        Integer[] arr = {10,12,14,19};  
        MyArrays<Integer> tool = new MyArrays<Integer>();
        tool.reverse(arr);
        System.out.println("数组的元素："+tool.toString(arr));
        MyArrays<String> tool2 = new MyArrays<String>();
        String[] arr2 = {"aaa","bbb","ccc"};
        tool2.reverse(arr2);
    }
}

7.4 应用4： 泛型接口

泛型接口的定义格式:

interface 接口名<声明自定义泛型>{

}

泛型接口注意事项：

1.接口上自定义的泛型的具体数据类型是在实现一个接口的时候指定的。
2.在接口上自定义的泛型如果在实现接口的时候没有指定具体的数据类型，那么默认为Object类型。

interface Dao<T>{
    public void add(T t);
}
public class test<T> implements Dao<T> {
    public static void main(String[] args) {
        test<String> d = new test<String>();
    }
    public void add(T t){

    }
}

7.5 泛型的上下限：

需求1： 定义一个函数可以接收接收任意类型的集合对象， 要求接收的集合对象只能存储Integer或者是Integer的父类类型数据。
需求2： 定义一个函数可以接收接收任意类型的集合对象， 要求接收的集合对象只能存储Number或者是Number的子类类型数据。

泛型中通配符：?

? super Integer：只能存储Integer或者是Integer父类元素（泛型下限）
? extends Number：只能存储Number或者是Number类型的子类数据（泛型上限）

public class test {
public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    ArrayList<Number> list2 = new ArrayList<Number>();
    HashSet<String> set = new HashSet<String>();
    //getData(set);
}
//泛型的上限
public static void getData(Collection<? extends Number> c){

}
//泛型的下限
public static void print(Collection<? super Integer> c){

}

}

8 可变参数

格式：

 数据类型... 变量名

可变参数注意细节：

1.如果一个函数的形参使用上了可变参数之后，那么调用该方法的时候可以传递参数也可以不传递参数。
2. 可变参数实际上是一个数组对象。
3.可变参数必须位于形参中的最后一个参数。
4.一个函数最多只能有一个可变参数，因为可变参数要位于形参中最后一个位置上。

public class test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        add(arr);//10
        add();//0
    }
    public static void add(int... arr){ //长度是0
        int result = 0;
        for(int item : arr){
            result+=item;
        }
        System.out.println("总和："+ result);
    }
}

9 时间类

Date、Calendar、SimpleDateFormat

public class test {
    public static void main(String[] args) throws ParseException {
        // Date获取当前的系统时间，过时
        Date date = new Date();
        System.out.println("年份："+ (date.getYear()+1900));
        // Calendar获取当前的系统时间
        Calendar calendar = Calendar.getInstance();
        System.out.println("年："+ calendar.get(Calendar.YEAR));
        System.out.println("月："+ (calendar.get(Calendar.MONTH)+1));
        System.out.println("日："+ calendar.get(Calendar.DATE));
        System.out.println("时："+ calendar.get(Calendar.HOUR_OF_DAY));
        System.out.println("分："+ calendar.get(Calendar.MINUTE));
        System.out.println("秒："+ calendar.get(Calendar.SECOND));
        // SimpleDateFormat格式化日期
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss") ; //使用了默认的格式创建了一个日期格式化对象。
        String time = dateFormat.format(date);  //可以把日期转换转指定格式的字符串
        System.out.println("当前的系统时间："+ time);
        String birthday = "1993年11月28日 00:00:00";
        Date date2 = dateFormat.parse(birthday);  //注意： 指定的字符串格式必须要与SimpleDateFormat的模式要一致。
        System.out.println(date2);// Sun Nov 28 00:00:00 CST 1993
    }
}

10 Math类

提供很多数学公式

Math类 —-abs(double a) 获取绝对值 —-ceil(double a) 向上取整 —-floor(double
a) 向下取整 —-round(float a) 四舍五入 —-random() 产生一个随机数，大于等于 0.0 且小于 1.0
的伪随机 double 值

public class test {
    public static void main(String[] args) {
        System.out.println("绝对值:"+Math.abs(-3));
        System.out.println("向上取整："+Math.ceil(3.14)); //4.0
        System.out.println("向下取整："+Math.floor(-3.14)); //-4.0
        System.out.println("四舍五入:"+Math.round(3.54)); //4
        System.out.println("随机数："+Math.random());
    }
}

11 Random类

public class test {
    public static void main(String[] args) {
        Random random = new Random();
        int randomNum = random.nextInt(10); //产生的随机数在0-9之间
        System.out.println("随机数："+ randomNum);
        char[] arr = {'孙','剑','峰','s','u','n'};
        StringBuilder sb = new StringBuilder();
        //产生四个arr中的值
        for(int i  = 0 ; i< 4 ; i++){
            //产生的随机数必须是数组的索引值范围之内的
            int index = random.nextInt(arr.length);
            sb.append(arr[index]);
        }
        System.out.println("4位验证码："+ sb);
    }
}

12 正则表达式

public class test {
    public static void main(String[] args) {
        //正则匹配
        String qq = "1724338257";
        System.out.println(qq.matches("\\d{5,11}"));//true
        //根据重叠词进行切割
        String str = "我叫叫叫孙剑剑峰峰峰";
        String[] data = str.split("(.)\\1+");//正则分组
        System.out.println(Arrays.toString(data));//[我, 孙]
        //替换
        String str2 = "我我我我要要要学学学习习";
        str2 = str2.replaceAll("(.)\\1+", "$1");
        System.out.println(str2);//我要学习
        //找出两个字母组成的单词
        String str3 = "Time is so precious.";
        String reg = "\\b[a-zA-Z]{2}\\b";
        //step1：把字符串正则编译成Pattern对象
        Pattern p = Pattern.compile(reg);//正则对象
        //step2：使用正则对象匹配字符串用于产生一个Matcher对象
        Matcher m = p.matcher(str3);//匹配器对象
        while(m.find()){
            System.out.println("获取结果："+m.group());
        }
    }
}

13 System系统类

主要用于获取系统的属性数据

System类常用方法： —-arraycopy(Object src, int srcPos, Object dest, int
destPos, int length) ——–src - 源数组。 ——–srcPos - 源数组中的起始位置。
——–dest - 目标数组。 ——–destPos - 目标数据中的起始位置。 ——–length - 要复制的数组元素的数量。 —-currentTimeMillis() 获取当前系统时间 —-exit(int status)
退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm，对一般使用没有区别 —-gc()
建议jvm赶快启动垃圾回收期回收垃圾 —-getenv(String name) 根据环境变量的名字获取环境变量
—-getProperty(key) —-finalize() 一个对象被垃圾回收器回收的时候，会先调用对象的finalize()方法

import java.util.*;
class Person{
    String name;
    public Person(String name) {
        this.name = name;
    }
    @Override
    public void finalize() throws Throwable {
        super.finalize();
        System.out.println(this.name+"被回收了");
    }
}
public class test {
    public static void main(String[] args) {
        int[] srcArr = {10,12,14,16,19};
        //把srcArr的数组元素拷贝 到destArr数组中。
        int[] destArr = new int[4];
        System.arraycopy(srcArr, 1, destArr, 0, 4);
//      System.exit(0);
        System.out.println("目标数组的元素："+ Arrays.toString(destArr)); // [12, 14, 16, 19]
        System.out.println("当前的系统时间：" + System.currentTimeMillis()); // 1484482029821
        System.out.println("环境变量："+System.getenv("JAVA_HOME")); // C:\Program Files\Java\jdk1.8.0_102
        for(int i = 0 ; i<4; i++){
            new Person("对象"+i);
            System.gc(); //建议马上启动垃圾回收期
        }
        Properties properties = System.getProperties();  //获取系统的所有属性。
        properties.list(System.out);
        String value = System.getProperty("os.name");//根据系统的属性名获取对应的属性值
        System.out.println("当前系统："+value);
    }
}

14 Runtime

RunTime类主要代表应用程序运行的环境

常用方法 —-getRuntime() 返回当前应用程序的运行环境对象 —-exec(String command)
根据指定的路径执行对应的可执行文件 —-freeMemory() 返回 Java 虚拟机中的空闲内存量，以字节为单位
—-maxMemory() 返回 Java 虚拟机试图使用的最大内存量 —-totalMemory() 返回 Java 虚拟机中的内存总量

public class test {
    public static void main(String[] args) throws IOException, InterruptedException {
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec("C:\\Windows\\notepad.exe");
        Thread.sleep(3000); //让当前程序停止3秒。
        process.destroy();
        System.out.println(" Java虚拟机中的空闲内存量。"+runtime.freeMemory());
        System.out.println("Java 虚拟机试图使用的最大内存量:"+ runtime.maxMemory());
        System.out.println("返回 Java 虚拟机中的内存总量:"+ runtime.totalMemory());
    }
}

15 junit(单元测试框架)

注意细节：

@Test测试的方法不能是static的，且不能带形参 如果测试一个方法的时候需要准备测试的环境或者清理测试的环境，可以使用@Before、
@After 、@BeforeClass、 @AfterClass注解。@Before、@After
是在每个测试方法测试的时候都会调用一次，@BeforeClass、@AfterClass是在所有的测试方法测试之前与测试之后调用一次而已。

junit使用规范：

1.一个类如果需要测试，那么该类就应该对应着一个测试类，测试类的命名规范：被测试类的类名+ Test
2.一个被测试的方法一般对应着一个测试的方法，测试的方法的命名规范是：test+ 被测试的方法的方法名

Demo1-被测试类

public class Tool {
    public static int getMax(){
        int a = 3;
        int b  =5; 
        int max = a>b?a:b;
        return max;
    }
}

Demo1-测试类

public class ToolTest {
    @Test
    public void testGetMax(){
        int max = Tool.getMax();
        if(max!=5){
            throw new RuntimeException();
        }else{
            System.out.println("最大值："+ max);
        }
        //断言
//      Assert.assertSame(5, max); // expected 期望   actual  真实     ==
//      Assert.assertSame(new String("abc"), "abc");
//      Assert.assertEquals(new String("abc"), "abc"); //底层是使用Equals方法比较的
//      Assert.assertNull("aa");
//      Assert.assertTrue(true);
    }
}

Demo2-被测试类

public class test1 {
    @Test //注解
    public void getMax(){
        int a = 3;
        int b = 5 ;
        int max = a>b?a:b;
        System.out.println("最大值："+max);
    }
    @Test
    public void sort(){
        int[] arr = {12,4,1,19};
        for(int i = 0 ; i  < arr.length-1 ; i++){
            for(int j = i+1 ; j<arr.length ; j++){
                if(arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("数组的元素："+Arrays.toString(arr));
    }
}

Demo2-测试类

public class test2 {
    //准备测试的环境
    //@Before
    @BeforeClass
    public static void beforeRead(){
        System.out.println("准备测试环境成功...");
    }
    //读取文件数据，把把文件数据都
    @Test
    public void readFile() throws IOException{
        FileInputStream fileInputStream = new FileInputStream("F:\\a.txt");
        int content  = fileInputStream.read();
        System.out.println("内容："+content);
    }
    @Test
    public void sort(){
        System.out.println("读取文件数据排序..");
    }
    //清理测试环境的方法
//  @After 
    @AfterClass
    public static void afterRead(){
        System.out.println("清理测试环境..");
    }
}

16 bat批处理文件

常用命令： echo 向控制台输出指定的内容 echo off 隐藏echo off后面执行过的命令 @ 隐藏当前行执行的命令 title
改变当前控制台窗口的标题 color 指定控制台的背景颜色与前景颜色 % 注释的内容% pause 让当前控制台停留 %1~%9
给bat处理文件传入参数