Scanner

获取键盘的输入

  1. public class TextScanner {
  2.     public static void main(String[] args) {
  3.         Scanner scan = new Scanner(System.in);  //System.in一个io流对象
  4.         System.out.println("输入字符：");
  5.         String a = scan.nextLine();        //获取输入的字符
  6.         System.out.println("输入数字：");
  7.         int b = scan.nextInt();            //获取输入的数字
  8.         System.out.println("#########");
  9.         System.out.println(a);
  10.         System.out.println(b);
  11.         scan.close();            
  12.     }
  13. }

包装类

基本数据类型不是对象，实际应用中经常需要将基本数据转化成对象，以便于操作。Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类
image.png

  1. public class WrapperClass {
  2.     public static void main(String[] args) {
  3.         //基本数据类型转为包装对象
  4.         Integer a = new Integer(3);
  5.         Integer b = Integer.valueOf(30);  //推荐这种
  7.         //把包装类对象转成基本数据类型
  8.         int c = b.intValue();        //转成整数
  9.         double d = b.doubleValue();
  11.         System.out.println(c);
  12.         System.out.println(d);
  14.         //把字符串转成包装类对象
  15.         Integer e = new Integer("233"); 
  16.         Integer f = Integer.parseInt("345");
  18.         System.out.println(e);
  20.         //把包装类对象转成字符串
  21.         String str = f.toString();
  23.         //常见的常量
  24.         System.out.println("int最大整数"+Integer.MAX_VALUE);
  25.     }
  26. }

自动装箱

  1.   基本类型的数据处于需要对象的环境中时，会自动转为"对象"

自动拆箱

  1.   每当需要一个值时，**对象会自动转成基本数据类型**，没必要再去显式调用intValue()、doubleValue()等转型方法
  1. public class AutoBox {
  2.     public static void main(String[] args) {
  4.         Integer a = 123;//自动装箱，编译器自动转换为对象
  6.         int b = a;  //自动拆箱，编译器自动修改
  8.         System.out.println("########");
  9.         //缓存[-128，127]之间的数字,系统在初始化时创建了[-128，127]之间的缓存数组
  10.         Integer in1 = Integer.valueOf(-128);
  11.         Integer in2 = -128;
  12.         Integer in3 = 128;
  14.         System.out.println(in2 == in3);//false  两个是不同的对象
  15.         System.out.println(in1 == in2);//true 因为在缓存范围内
  16.         System.out.println(in1.equals(in2));//true hashcode相同
  18.     }
  19. }

String类

三大特性

  • String类又称作不可变字符序列，主要在一个对象被多个线程频繁访问时，可以保证数据的一致性（不可变是值，当对string进行操作时，它本身的对象不会改变，任何对它的操作都是创建一个新的对象）
  • 常量池优化：string对象在创建之后，会在常量池中进行缓存，下次创建同样的对象时，会直接返回缓存的引用；字符串常量池位于堆内存中
  • final：string类不可被继承，提高了系统的安全性

实例化的两种方式:

  • 直接赋值
  • 通过构造函数，可以直接将字符串的值传入，也可以传入一个char数组。

注：直接赋值和通过构造函数创建主要区别在于存储的区域不同，直接赋值存储在字符串常量池中。通过构造函数创建，存储在堆内存中

构造器方法

image.png

Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例

image.png

  1. //string 常用用法
  2. public class TextString {
  3.     public static void main(String[] args) {
  4.             String s1 = "core Java";
  5.             String s2 = "Core Java";
  6.             System.out.println(s1.charAt(3));//提取下标为3的字符
  7.             System.out.println(s2.length());//字符串的长度
  8.             System.out.println(s1.equals(s2));//比较两个字符串是否相等
  9.             System.out.println(s1.equalsIgnoreCase    (s2));//比较两个字符串（忽略大小写）
  10.             System.out.println(s1.indexOf("Java"));//字符串s1中是否包含Java
  11.             System.out.println(s1.indexOf("apple"));//字符串s1中是否包含apple
  12.             String s3 = s1.replace(' ', '&');//将s1中的空格替换成&
  13.             System.out.println("result is :" + s3);
  14.             System.out.println("######");
  16.             //contains() 方法用于判断字符串中是否包含指定的字符或字符串
  17.             System.out.println(s3.contains("aaa"));//返回一个布尔值
  19.             String s = "";
  20.             String s5 = "How are you?";
  21.             System.out.println(s5.startsWith("How"));//是否以How开头
  22.             System.out.println(s5.endsWith("you"));//是否以you结尾
  23.             s = s5.substring(4);//提取子字符串：从下标为4的开始到字符串结尾为止
  24.             System.out.println(s);
  25.             s = s5.substring(4, 7);//提取子字符串：下标[4, 7) 不包括7
  26.             System.out.println(s);
  27.             s = s5.toLowerCase();//转小写
  28.             System.out.println(s);
  29.             s = s5.toUpperCase();//转大写
  30.             System.out.println(s);
  31.             String s6 = "  How old are you!! ";
  32.             s = s6.trim();//去除字符串首尾的空格。注意：中间的空格不能去除
  33.             System.out.println(s);
  34.             System.out.println(s6);//因为String是不可变字符串，所以s2不变
  36.     }
  37. }

split()方法

字符串的分割；支持正则表达式

  1. String nn = new String("hh,mm,ss");
  2. String[] split = nn.split(",");        //按照指定字符分割
  3. for (String s1 : split) {
  4.     System.out.println(s1);
  5. }
  7. String mn = new String("hh,mm;s-s");
  8. mn.split("[,|;|-]");
  9. for (String s1 : split) {
  10.     System.out.println(s1);
  11. }

intern()方法

当调用某个字符串对象的intern()方法，会去字符串常量池中寻找，如果已经存在一个值相等的字符串对象的话，则直接返回该对象的引用。如果不存在，则在字符串常量池中创建该对象

  1. String m = "hh";
  2. String n = new String("hh");
  4. System.out.println(m==n);            //false 比较的是地址
  5. System.out.println(m==n.intern());  //true比较的是值

考点

  1. String s1 = "hh";
  2. String s2 = "h"+"h";      //常量和常量拼接
  3. System.out.println(s1==s2); //true
  5. String s4 = "hh";
  6. String s5 = "h";
  7. s5+="h";        //修改之后再拼接 存放在堆内存中
  8. System.out.println(s1==s3); //false
  10. String s1 = "hh";
  11. String s2 = "h";      
  12. String s3= "h"+s2;        //常量和变量拼接 存放在堆中
  13. System.out.println(s1==s3);        //false
  15. String s3 = "hh";
  16. final String s4 = "h";      //final修饰后作为一个常量用
  17. String s5= "h"+s4;
  18. System.out.println(s3==s5);        //true
  20. String s6 = "hh";
  21. final String s7 = new String("h");  //s7是一个存放在堆内的对象
  22. String s8= "h"+s7;
  23. System.out.println(s6==s8);        //false

为什么String不可变

不可变指类的实例一旦被创建后，其内容就是不可变的

  • 类被final修饰，不可继承
  • 底层value数组用final修饰，初始化后，就不能改变它的引用
  • 没有暴露成员变量。成员变量的访问修饰符是private，也没有提供方法去访问，要修改只能通过string提供的方法
  • string类中的方法不会改动value中的元素，需要改变的话都是直接创建一个新的string对象返回

好处

  • 提高安全性
  • 节省空间。通过维护字符串常量池
  • 线程安全。调用string方法去修改string对象时返回的是新的对象，不存在并发修改同一个对象的场景
  • 提高性能。比如string的哈希码只用计算一次，以后调用的都是缓存

StringBuffer和StringBuilder

可变的字符序列， 这两个类都是抽象类

  1. //StringBuilder线程不安全 效率高(一般使用它)
  2. //StringBuffer 线程安全 效率低
  3. StringBuilder a = new StringBuilder("abc");
  4. System.out.println(Integer.toHexString(a.hashCode()));//打印hash地址
  5. System.out.println(a);
  7. a.setCharAt(1, 'B'); //改变字符
  8. System.out.println(Integer.toHexString(a.hashCode()));
  9. System.out.println(a);

常用方法

  1. public class TextStringBuilder2 {
  2.     public static void main(String[] args) {
  4.         StringBuilder a = new StringBuilder();
  6.         for (int i = 0; i < 7; i++) {
  7.             char temp = (char)('A'+i);
  8.             a.append(temp);//append方法 数组对象不变 累加字符序列
  9.         }
  10.         System.out.println(a);
  11.         a.reverse();//倒序
  12.         System.out.println(a);
  13.         a.setCharAt(1, 'B');
  14.         System.out.println(a);
  15.         a.insert(2, 'a');
  16.         System.out.println(a);
  17.         a.insert(0, 'z').insert(1,'y').insert(2,'x');//链式调用 因为该方法每次都是返回自己
  18.         System.out.println(a);
  19.         a.delete(1, 3);//删除某个区间 也可以链式调用
  20.         System.out.println(a);
  21.         }    
  22.     }

注：累加字符序列用stringbuilder append方法 防止创建多个对象影响程序效率

时间类

Date时间类(java.util.Date)

DateFormat类和SimpleDateFormat类
把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。DateFormat是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现

  1. public class TextDate {
  2.     public static void main(String[] args) throws ParseException {        
  3.         Date d = new Date();  //什么都不传表示当前时刻
  4.         System.out.println(d);
  5.         System.out.println(d.getTime()); //返回一个毫秒数
  7.         //把时间对象按照指定格式转换成字符串
  8.         DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
  9.         String str = df.format(new Date(666666));//格式化时间转成字符串
  10.         System.out.println(str);    
  12.         //把字符串按照指定格式转换成时间对象
  13.         DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
  14.         Date date = df2.parse("2020-6-27 18:8:8");//解析时间    
  15.         System.out.println(date);    //时间格式 Sat Jun 27 18:08:08 CST 2020
  17.         //D字符 获得本时间式所处年份的第几天
  18.         DateFormat df3 = new SimpleDateFormat("D");
  19.         String str3 = df3.format(new Date());
  20.         System.out.println(str3);    
  21.     }
  22. }

注：
image.png

Calendar日历类

Calendar 类是一个抽象类，提供了关于日期计算的相关功能
GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统

  1. public class TextCalendar {
  2.     public static void main(String[] args) {
  3.         Calendar calendar = new GregorianCalendar();//不输入 默认当前日期    
  5.         //日期计算
  6.         calendar.get(Calendar.DATE);    //获取当前天数
  7.         calendar.add(Calendar.DATE, 100);//往后100天的日期
  8.         System.out.println(calendar);
  10.         //日期对象和时间对象的转换
  11.         Date d4 = calendar.getTime();//geTime()方法返回当前的时间
  12.         System.out.println(d4);        //日期对象转换成时间对象
  13.         Calendar c = new GregorianCalendar();
  14.         c.setTime(new Date());    //转成对应的日历类
  15.         System.out.println(c);
  17.         System.out.println("######");
  18.         printCalendar(c);    //封装方法打印日期类
  20.     }
  21.     public static void printCalendar(Calendar c) {
  22.         int year = c.get(Calendar.YEAR);
  23.         int month = c.get(Calendar.MONTH)+1;//0-11表示对应的月份
  24.         int day = c.get(Calendar.DAY_OF_MONTH);
  25.         int dayweek = c.get(Calendar.DAY_OF_WEEK);
  27.         int hour = c.get(Calendar.HOUR);
  28.         int min = c.get(Calendar.MINUTE);
  29.         int sec = c.get(Calendar.SECOND);
  31.         System.out.println(year+"-"+month+"-"+day+" "+dayweek+" "+hour+":"+min+":"+sec);
  33.     }
  34. }

练习

  1. //将一个时间字符串增加n天后返回
  2. public static void main(String[] args) throws ParseException {
  3.     DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
  4.     Date date = df2.parse("2020-6-27 18:8:8");//解析时间
  5.     Calendar calendar = new GregorianCalendar();
  6.     calendar.setTime(date);
  7.     calendar.add(Calendar.DATE, 10);
  8.     Date time = calendar.getTime();
  9.     String format = df2.format(time);
  10.     System.out.println(format);
  11. }

LocalDateTime

  1. #实例创建的方式--静态方法
  2. LocalDateTime localDateTime = LocalDateTime.now();
  3. LocalDateTime time = LocalDateTime.of(2022, 3, 26, 0, 0);
  1. #日期的获取--类似与calendar
  2. localDateTime.getDayOfMonth();
  4. #日期的增加、减少    这几个api返回的都是新对象
  5. LocalDateTime dateTime = localDateTime.plusDays(10);
  6. LocalDateTime time = localDateTime.minusDays(10);
  7. //将日期的某个值修改为指定值后返回
  8. LocalDateTime dateTime = localDateTime.withDayOfMonth(6);
  10. //获取当前时间 有时差问题
  11. Instant instant = Instant.now();    
  12. System.out.println(instant);
  13. //添加时差偏移量
  14. OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
  15. System.out.println(offsetDateTime);
  17. //获取时间戳 有时差
  18. long l1 = instant.toEpochMilli();
  19. Instant instant1 = Instant.ofEpochMilli(l1);
  20. System.out.println(instant1);
  22. #计算两个时间之间的间隔  Duration以秒和纳秒为基准; Period以年、月、日为衡量
  23. LocalDateTime time1 = LocalDateTime.now();
  24. LocalDateTime time2 = LocalDateTime.of(2022, 3, 26, 0, 0);
  25. Duration duration = Duration.between(time2, time1);
  26. System.out.println(duration.getSeconds());
  1. #格式化时间
  2. String format = formmater.format(LocalDateTime.now());
  3. System.out.println(format);
  5. TemporalAccessor parse = formmater.parse("2022-03-26 02:46:37");
  6. System.out.println(parse);

Math类

  1. public class TestMath {
  2.     public static void main(String[] args) {
  3.         //取整相关操作
  4.         System.out.println(Math.ceil(3.2));
  5.         System.out.println(Math.floor(3.2));
  6.         System.out.println(Math.round(3.2));//四舍五入
  7.         System.out.println(Math.round(3.8));
  8.         //绝对值、开方、a的b次幂等操作
  9.         System.out.println(Math.abs(-45));
  10.         System.out.println(Math.sqrt(64));
  11.         System.out.println(Math.pow(5, 2));
  12.         System.out.println(Math.pow(2, 5));
  13.         //Math类中常用的常量
  14.         System.out.println(Math.PI);
  15.         System.out.println(Math.E);
  16.         //随机数
  17.         System.out.println(Math.random());// [0,1)
  18.     }
  19. }

Math.random()类

  1. public class TestRandom {
  2.     public static void main(String[] args) {
  3.         //随机数
  4.         System.out.println(Math.random());// [0,1)
  5.         Random rand = new Random();
  6.         //随机生成[0,1)之间的double类型的数据
  7.         System.out.println(rand.nextDouble());
  8.         //随机生成int类型允许范围之内的整型数据
  9.         System.out.println(rand.nextInt());
  10.         //随机生成[0,1)之间的float类型的数据
  11.         System.out.println(rand.nextFloat());
  12.         //随机生成false或者true
  13.         System.out.println(rand.nextBoolean());
  14.         //随机生成[0,10)之间的int类型的数据
  15.         System.out.print(rand.nextInt(10));
  16.         //随机生成[20,30)之间的int类型的数据
  17.         System.out.print(20 + rand.nextInt(10));
  18.     } 
  19. }

File类的基本用法

java.io.File类：代表文件和目录。 在开发中，读取文件、生成文件、删除文件、修改文件的属性时经常会用到本类。

  1. //文件类的使用
  2. public class TextFile {
  3.     public static void main(String[] args) throws IOException {
  5.         //user.dir就是本项目的目录 
  6.         System.out.println(System.getProperty("user.dir"));
  8.         File f = new File("gg.txt");//相对路径 默认当前项目下
  9.         f.createNewFile();
  11.         System.out.println("File是否存在："+f.exists());
  12.         System.out.println("File是否是目录："+f.isDirectory());
  13.         System.out.println("File是否是文件："+f.isFile());
  14.         System.out.println("File最后修改时间："+new Date(f.lastModified()));
  15.         System.out.println("File的大小："+f.length());
  16.         System.out.println("File的文件名："+f.getName());
  17.         System.out.println("File的目录路径："+f.getPath());//相对路径
  18.         System.out.println(f.getAbsolutePath());//绝对路径
  20.         f.delete();
  22.         //mkdir使用  
  23.         File f2 = new File("d:/电影/华语/大陆");
  24.         boolean flag = f2.mkdir(); //目录结构中有一个不存在，则不会创建整个目录树
  25.         System.out.println(flag);//创建失败
  27.         //mkdirs  创建整个目录树
  28.         File f3 = new File("c:/电影/华语/大陆");
  29.         boolean flag1 = f3.mkdirs();
  30.         System.out.println(flag1);
  31.         System.out.println(f3.getAbsolutePath());
  33.         f3.delete();
  35.     }
  36. }

使用递归算法，以树状结构展示目录树

  2. //递归遍历目录树
  3. public class TextFile2 {
  4.     public static void main(String[] args) {
  6.         File f1 = new File("C:\\C语言\\eclipse\\eclipse jee\\Practice\\src\\CommonClass");
  7.         printFile(f1,0);
  8.         countfile(f1);
  9.         System.out.println(len);
  10.     }
  12.     static void printFile(File file,int n) {
  14.         //输出层级
  15.         for (int i = 0; i < n; i++) {
  16.             System.out.print("-");
  17.         }
  18.         System.out.println(file.getName());
  19.         if (file.isDirectory()) {
  20.             File[] files = file.listFiles();//返回子目录子文件
  21.             for (File temp : files) {
  22.                 printFile(temp,n+1);
  23.             }
  24.         }
  26.     }
  28.     //统计文件内容的大小
  29.     private static long len=0;
  30.      static void countfile(File file) {
  31.         if(file.exists()) {
  32.             if(file.isFile()) {
  33.                 len += file.length();
  34.             }else {
  35.                 for(File tempFile:file.listFiles()) {
  36.                     countfile(tempFile);
  37.                 }
  38.             }
  39.         }
  41.     }
  42. }
  1. //使用面向对象方法实现文件大小的统计
  2. public class CountFile {
  3.     private static long len;
  4.     private String dirpath; //文件夹路径
  5.     private File srcFile; //源头文件
  6.     private int filesize; //文件个数
  7.     private int dirsize; //文件夹个数
  10.     public CountFile(String dirpath) {
  11.         super();
  12.         this.dirpath = dirpath;
  13.         this.srcFile = new File(dirpath);//传入对象
  14.         countfile(this.srcFile);
  15.     }
  17.     //统计文件内容的大小
  18.     private void countfile(File file) {
  19.             if(file.exists()) {
  20.                 if(file.isFile()) {
  21.                     len += file.length();
  22.                     this.filesize++;
  24.                 }else {
  25.                     this.dirsize++;
  26.                     for(File tempFile:file.listFiles()) {
  27.                         countfile(tempFile);
  28.                     }
  29.                 }
  30.             }
  32.         }
  34.     public static long getLen() {
  35.         return len;
  36.     }
  38.     public int getFilesize() {
  39.         return filesize;
  40.     }
  42.     public int getDirsize() {
  43.         return dirsize;
  44.     }
  46.     public static void main(String[] args) {
  47.         CountFile coun1 = new CountFile("C:/C语言/eclipse/eclipse jee/Practice");
  48.         System.out.println(coun1.getLen());
  49.         System.out.println(coun1.getFilesize());
  50.         System.out.println(coun1.getDirsize());
  51.     }
  52. }