JAVA学习笔记

JAVA入门
- 封装——四个访问控制符
- 多态
- 对象的转型
- 抽象方法_抽象类
- 接口的定义和实现
- String类常用方法
- 异常处理
- - FileReader 读取文件异常处理
  - JDK新特性_try-with-resource（自动关闭Closeable接口的资源）
  - 包装类基本用法
  - StringBuilder和StringBuffer用法
  - 字符序列陷阱_时间和空间效率测试
  - - 使用StringBuilder进行字符串的拼接既高效又节省空间
  - Date类用法
  - DateFormat时间格式化类
  - Math类和Random类
  - File类的使用
  - File类_递归_打印目录树结构
  - 枚举_switch语句复习
- 容器
- - 泛型类
  - 泛型接口
  - 泛型方法_非静态方法
  - 泛型方法_静态方法
  - 泛型方法与可变参数
  - 无界通配符
  - 统配符的上限限定
  - 统配符的上限限定
  - 泛型总结
  - Java中的容器结构

JAVA入门封装——四个访问控制符

多态

对象的转型

抽象方法_抽象类

接口的定义和实现

String类常用方法

package project02;

public class StringTest1 {
    public static void main(String[] args) {
        String s1 = "core Java";
        String s2 = "Core Java";
        System.out.println(s1.charAt(3)); //提取下标为3的字符
        System.out.println(s2.length());  //字符串的长度
        System.out.println(s1.equals(s2));  //比较两个字符串是否相等
        System.out.println(s1.equalsIgnoreCase(s2)); //比较两个字符串（忽略大小写）
        System.out.println(s1.indexOf("Java"));   //字符串s1中是否包含Java    返回首次出现的位置
        System.out.println(s1.indexOf("apple"));  //字符串s1中是否包含apple

        String s = s1.replace(' ','&');  //将s1中的空格替换成&
        System.out.println("result is "+s);

    }
}

package project02;

public class StringTest2 {
    public static void main(String[] args) {
        String s = "";
        String s1 = "How are you?";
        System.out.println(s1.startsWith("How"));  //是否以How开头
        System.out.println(s1.endsWith("you"));   //是否以you结尾
        s = s1.substring(4); //提取字符串：从下标为4开始到字符串结尾为止
        System.out.println(s);
        s = s1.substring(4,7); //提取字符串 [4,7)   不包括7
        System.out.println(s);
        s = s1.toLowerCase();  //全部转小写
        System.out.println(s);
        s = s1.toUpperCase();   //全部转大写
        System.out.println(s);
        String s2 = " How old are you!  ";
        s = s2.trim();  //去除字符串首尾的空格。 中间空格不能去除
        System.out.println(s);
    }
}

异常处理 FileReader 读取文件异常处理

package project03;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class test01 {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
              reader = new FileReader("C:/Users/kangyi/Desktop/a.txt");
              char[] cbuf  =new char[1000];
              int len = reader.read(cbuf);
              System.out.println(new String(cbuf,0,len));
//            reader = new FileReader("C:/Users/kangyi/Desktop/a.txt");
//            char c = (char)reader.read();
//            char c1 = (char)reader.read();
//            char c2 = (char)reader.read();
//            System.out.println("文本内容为:"+c+c1+c2);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(reader != null)
                {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

JDK新特性_try-with-resource（自动关闭Closeable接口的资源）

package project03;

import java.io.FileReader;
import java.io.IOException;

public class test03 {
    public static void main(String[] args) {
        try(FileReader reader = new FileReader("C:/Users/kangyi/Desktop/a.txt")){
            char[] cbuf = new char[1000];
            int len = reader.read(cbuf);
            System.out.println(new String(cbuf,0,len));
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

包装类基本用法

package project03;

public class test04 {
    public static void main(String[] args) {
        Integer i = new Integer(50);  //从Java9开始被废弃
        Integer j = Integer.valueOf(10);   //官方推荐

        int a = j.intValue();    //把包装类对象转成基本数据类型
        double b = j.doublevalue();

        //把字符串转成数字
        Integer m = Integer.valueOf("456");
    }
}

StringBuilder和StringBuffer用法

package project03;

public class test05 {
    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder("abc");
       // StringBuffer sb2 = new StringBuffer("abc");

        //   StringBuilder
        StringBuilder sb1 = new StringBuilder();
        for (int i =0;i<7;i++){
            sb.append((char)('a' + i )); //追加单个字符
        }
        System.out.println(sb.toString()); //转换成String输出
        sb.append(",I can sing my abc!");  // 追加字符串
        System.out.println(sb.toString());
        //StringBuffer,下面的方法同样适用于StringBuilder

        StringBuffer sb3 = new StringBuffer("北京尚学堂");
        sb3.insert(0,"爱").insert(0,"我"); //插入字符串
        System.out.println(sb3);
        sb3.delete(0,2); //删除字符串
        System.out.println(sb3);
        sb3.deleteCharAt(0).deleteCharAt(0);  //删除某个字符
        System.out.println(sb3.charAt(0));    //获取某个字符
        System.out.println(sb3.reverse());    //字符串逆序
    }
}

字符序列陷阱_时间和空间效率测试使用StringBuilder进行字符串的拼接既高效又节省空间

package project03;

import java.sql.SQLOutput;

public class test06 {
    public static void main(String[] args) {
        //使用String进行字符串的拼接
        String str = "abc";
        long num1 = Runtime.getRuntime().freeMemory(); // 获取系统剩余内存空间
        long time1 = System.currentTimeMillis(); //获取系统的当前时间
        for(int i = 0;i<5000;i++){
            str = str +i;  //相当于产生了5000个对象
        }
        long num2 = Runtime.getRuntime().freeMemory();
        long time2 = System.currentTimeMillis();
        System.out.println(str.toString());
        System.out.println("String占用内存:"+(num1-num2));
        System.out.println("String占用时间:"+(time2-time1));

        //  使用StringBuilder进行字符串的拼接
        StringBuilder sb1 = new StringBuilder("abc");
        long num3 = Runtime.getRuntime().freeMemory();
        long time3 = System.currentTimeMillis();
        for (int i = 0;i<5000;i++){
            sb1.append(i);
        }
        long num4 = Runtime.getRuntime().freeMemory();
        long time4 = System.currentTimeMillis();
        System.out.println(str.toString());
        System.out.println("String占用内存:"+(num3-num4));
        System.out.println("String占用内存:"+(time4-time3));
    }
}

结果：

Date类用法

package project03;

import java.util.Date;

public class test07 {
    public static void main(String[] args) {
        long time = System.currentTimeMillis();//获取当前计算机时间
        System.out.println(time);

        Date date1 = new Date();//new一个date，获取当前时间
        System.out.println(date1);
        System.out.println(date1.getTime());
        Date date2 = new Date(-21L*365*24*3600*1000);//计算机基点时间为1970，(-21L*365*24*3600*1000)倒回1949年
        System.out.println(date2);
        System.out.println(date2.equals(date1));//比较时间是否相等
        System.out.println(date2.before(date1));//比较两时间前后顺序
        System.out.println(date2.after(date1));//

    }
}

DateFormat时间格式化类

package project03;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

//测试DateFormat时间格式化类
public class DateFormat {
    public static void main(String[] args) throws ParseException {
        //字符串转时间
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//new一个时间格式
        String str = "2049-10-1 10:00:00";
        Date guoqing100 = format.parse(str);
        System.out.println(guoqing100.getTime()); //2516666400000
        System.out.println(guoqing100);   //Fri Oct 01 10:00:00 CST 2049

        //时间转字符串
        SimpleDateFormat format2 = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
        Date date2 = new Date(2344551651651L);
        String date2Str = format2.format(date2);
        System.out.println(date2Str);   //2044年04月18日 08时20分51秒

        //小妙招
        Date now = new Date();
        SimpleDateFormat f1 = new SimpleDateFormat("现在是今年的第D天，第w周。");
        String str3 = f1.format(now);
        System.out.println(str3);  //现在是今年的第349天，第51周。


    }
}

Math类和Random类

package project03;

//Math类
public class TestMath {
    public static void main(String[] args) {
        //取整相关操作
        System.out.println(Math.ceil(3.2));   //向上取整
        System.out.println(Math.floor(3.2));  //向下取整
        System.out.println(Math.round(3.2));   //四舍五入
        System.out.println(Math.round(3.8));

        //绝对值，开方，a的b次幂等操作
        System.out.println(Math.abs(-45));   //绝对值
        System.out.println(Math.sqrt(64));    //开方
        System.out.println(Math.pow(5,2));     //5的2次幂
        System.out.println(Math.pow(2,5));     //2的5次幂

        //Math类中常用的常量
        System.out.println(Math.PI);     //3.141592653589793
        System.out.println(Math.E);      //2.718281828459045

        //随机数
        System.out.println(Math.random());  //[0,1)

    }
}

package project03;
import java.util.Random;
//Random类
public class TestRandom {
    public static void main(String[] args) {
        Random rand = new Random();
        //随机生成[0,1)之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型允许范围内的整型数据
        System.out.println(rand.nextInt());
        //随机生成[0,1)之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或者true
        System.out.println(rand.nextBoolean());
        //随机生成[0,10)之间的int类型的数据
        System.out.println(rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据
        System.out.println(20+rand.nextInt(10));
        //随机生成[20，30)之间的int类型的数据(此种方法计算较为复杂)
        System.out.println(20+(int)(rand.nextDouble()*10));
    }
}

File类的使用

package project03;

import java.io.File;
import java.io.IOException;
import java.util.Date;

//  File类的用法
public class TestFile {
    public static void main(String[] args) throws IOException {
        System.out.println(System.getProperty("user.dir"));  //获取当前文件位置
        File f = new File("a.txt");  //相对路径:默认放到user.dir目录下面
        f.createNewFile();   //创建文件
        File f2 = new File("C:/Users/kangyi/b.txt");  //绝对路径
        f2.createNewFile();
        f2.delete();   //删除文件

        System.out.println("File是否存在:"+f.exists());
        System.out.println("File是否是目录:"+f.isDirectory());
        System.out.println("File是否是文件:"+f.isFile());
        System.out.println("File最后修改的时间:"+new Date(f.lastModified()));
        System.out.println("File的大小:"+f.length());

        File f3 = new File("C:/Users/kangyi/电影/华语/大陆");
        boolean flag = f3.mkdir();  // 目录结构中有一个不存在，则不会创建整个目录树
        System.out.println(flag);   //创建失败

        boolean flags = f3.mkdirs();  //目录结构中有一个不存在也没关系:创建整个目录树
        System.out.println(flags);   //创建成功

    }
}

File类_递归_打印目录树结构

package project03;

import java.io.File;

//打印目录树，结合递归
public class PrintFileTree {
    public static void main(String[] args) {
        File f = new File(System.getProperty("user.dir"));
        printFile(f,0);
    }

    static void printFile(File file,int level){
        for (int i=0;i 
枚举_switch语句复习 
package project03;
import java.util.Random;

//测试枚举_switch语句复习
public class TestEnum {
    public static void main(String[] args) {
        System.out.println(jijie.spring);
        System.out.println(Season.spring);

        for(Season s:Season.values()){
            System.out.println(s);
        }

        int a = new Random().nextInt(4); //生成0，1，2，3随机数
        switch (Season.values()[a]){
            case spring:
                System.out.println("春天");
                break;
            case summer:
                System.out.println("夏天");
                break;
            case autumn:
                System.out.println("秋天");
                break;
            case winter:
                System.out.println("冬天");
                break;
        }
    }
    
    //枚举
    enum Season{
        spring,summer,autumn,winter
    }

    //普通方法定义一个类
    class jijie{
        public static final int spring = 0;
        public static final int summer = 1;
        public static final int autumn = 2;
        public static final int winter = 3;
    }
}

 
容器 
泛型类 
 
package project04;

//泛型类
public class Generic {
    private T flag;

    public T getFlag() {
        return this.flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }

}
 
package project04;

// 测试类
public class TestGeneric {
    public static void main(String[] args) {
        Generic generic = new Generic<>();
        generic.setFlag("admin");
        String flag = generic.getFlag();
        System.out.println(flag);

        Generic generic1 = new Generic<>();
        generic1.setFlag(100);
        Integer flag1 = generic1.getFlag();
        System.out.println(flag1);
    }
}

 
泛型接口 
package project04;

//定义一个泛型接口
public interface Igeneric {
    T getName(T name);
}

 
package project04;

//定义一个接口实现类
public class IgenericImpl implements Igeneric{
    @Override
    public String getName(String name) {
        return name;
    }
}

 
package project04;

//测试类
public class TestIgeneric {
    public static void main(String[] args) {
        IgenericImpl igeneric = new IgenericImpl();
        String name = igeneric.getName("kangyi");
        System.out.println(name);

        Igeneric igeneric1 = new IgenericImpl();
        String name1 = igeneric1.getName("kangkang");
        System.out.println(name1);

    }
}

 
泛型方法_非静态方法 
非静态方法使用泛型有两种情况:
 1.通过泛型类的泛型来使用
 2.通过泛型方法的方式来使用泛型 
 
package project04;

//泛型方法
public class MethodGeneric {

    //定义一个无返回值的泛型方法
    public  void setName(T name){
        System.out.println(name);
    }

    //定义一个有返回值的泛型方法
    public  T getName(T name){
        return name;
    }
}

 
package project04;

//泛型方法测试类
public class TestMethodGeneric {
    public static void main(String[] args) {
        MethodGeneric methodGeneric = new MethodGeneric();
        methodGeneric.setName("kangyi");
        methodGeneric.setName(123456);

        MethodGeneric methodGeneric1 = new MethodGeneric();
        String name = methodGeneric1.getName("kangkang");
        Integer name1 = methodGeneric1.getName(123);
        System.out.println(name);
        System.out.println(name1);
    }
}

 
泛型方法_静态方法 
静态方法使用泛型的方式只有一个:即只能在静态方法上定义泛型 
package project04;

//泛型方法
public class MethodGeneric {

    //非静态方法
    //定义一个无返回值的泛型方法
    public  void setName(T name){
        System.out.println(name);
    }

    //定义一个有返回值的泛型方法
    public  T getName(T name){
        return name;
    }

    //静态方法
    public static  void setFlag(T flag){
        System.out.println(flag);
    }

    public static  T getFlag(T flag){
        return flag;
    }
}

 
package project04;

public class TestStaticMethodGeneric {
    public static void main(String[] args) {
        MethodGeneric.setFlag("kangyi");
        MethodGeneric.setFlag(123456);

        String flag = MethodGeneric.getFlag("kangkang");
        System.out.println(flag);
        Integer flag1 = MethodGeneric.getFlag(123456);
        System.out.println(flag1);

    }
}

 
泛型方法与可变参数 
package project04;

//泛型方法
public class MethodGeneric {

    //非静态方法
    //定义一个无返回值的泛型方法
    public  void setName(T name){
        System.out.println(name);
    }

    //定义一个有返回值的泛型方法
    public  T getName(T name){
        return name;
    }

    //静态方法
    public static  void setFlag(T flag){
        System.out.println(flag);
    }

    public static  T getFlag(T flag){
        return flag;
    }

    //使用泛型定义一个可变参数的方法
    public void method (T...args){
        for (T t :args){
            System.out.println(t);
        }

    }
}

 
package project04;

//测试泛型方法与可变参数
public class TestMethodGeneric01 {
    public static void main(String[] args) {
        MethodGeneric methodGeneric = new MethodGeneric();
        String[] arr = new String[]{"a","b","c"};
        Integer[] arr1 = new Integer[]{1,2,3};
        methodGeneric.method(arr);
        methodGeneric.method(arr1);
    }
}

 
无界通配符 
 
package project04;


//? 无界通配符(通配任何类型)
//使用通配符能对泛型是任何类型的Generic的对象中的值做输出
public class ShowMsg {
    public void showFlag(Generic generic){
        System.out.println(generic.getFlag());
    }
}

 
package project04;

//测试通配符
public class TestShowMsg {
    public static void main(String[] args) {
        ShowMsg showMsg = new ShowMsg();
        Generic generic = new Generic<>();
        generic.setFlag(20);
        showMsg.showFlag(generic);

        Generic generic1 = new Generic<>();
        generic1.setFlag(50);
        showMsg.showFlag(generic1);

        Generic generic2 = new Generic<>();
        generic2.setFlag("kangyi");
        showMsg.showFlag(generic2);
    }
}

 
统配符的上限限定 

  
 
统配符的上限限定 
 
泛型总结 
 
Java中的容器结构

JAVA学习笔记

Java相关栏目本月热门文章