java SE_3

A码

已于 2023-09-20 00:19:57 修改

阅读量37

点赞数

文章标签： java 开发语言

于 2023-09-17 22:49:23 首次发布

本文链接：https://blog.csdn.net/qq_41255707/article/details/132956945

版权

1.链式操作

链式操作：如果调用方法后的返回值是引用的类型，就可以继续调用下一个方法.

//StringBuffer 操作字符串的类
//StringBuffer 不是String， 他们是两个不同的类型
public class StringBufferDemo {
   public static void main(String[] args) {
      StringBuilder sb = new StringBuilder("今天");
      System.out.println(sb);
      // ** 链式操作  如果调用方法后的返回值是引用的类型，就可以继续调用下一个方法。
      String s = sb. append("我想去打游戏" ).insert( sb.indexOf("天"), "放学后").append(",然后在做作业。" ). delete( sb.indexOf("我想"),sb.indexOf("然后在")+3).reverse( ).toString( );
      System.out.println(s);
   }
}

2.Date类

java.util.Date用于封装日期和时间信息。
- Date date = new Date();
- date中的日期为系统的当前时间。
- 重写了toString方法，输出内容为日期。
Date类中大多数用于操作时间分量的方法都被Calendar取代。
Date中的getTime , setTime方法是用于获取/设置时间毫秒数。

3.SimpleDateFormat类

将日期类型，格式化为指定日期表示的字符串。
将符合日期格式的字符串，解析为日期类型。
日期符号： yyyy 年， MM 月， dd , 日
时间： HH 小时， hh小时， mm 分， ss 秒

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo {
   public static void main(String[] args) throws ParseException {
      //1.创建对象
      Date d = new Date();  //实例化 date中的日期为系统的当前时间。

      //2.Date 中重写了Object的toString方法：
      //Fri Aug 04 10:34:18 CST 2023
      System.out.println(d);  // 输出对象，调用toString()

      //3.创建对象
      SimpleDateFormat sdf = new SimpleDateFormat();
      sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

      //4.对日期进行格式化
      String dStr = sdf.format(d);
      System.out.println(dStr);

      //5.获取时间毫秒数(日期对象的)
      long time = d.getTime();
      System.out.println("毫秒数：" + time);

      //设置时间毫秒数
      d.setTime(1691116786443L - (24L * 60 * 60 * 365 * 1000));
      System.out.println(sdf.format(d));

      //7.设置一个指定日期
      d.setTime(0);
      System.out.println(sdf.format(d));

      String str = "2002.7.7";
      SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy.MM.dd");

      // ** format -- 格式化 ， parse -- 解析
      // 编译时异常：parse方法，定义的时候，抛出了异常。
      //          调用parse方法，需要处理这个异常（①抛出去， ②捕获）
      // ** java.text.ParseException: Unparseable date: "2002.7-7"
      Date d2 = sdf1.parse(str);  //字符串转换为日期
      System.out.println(d2);

      //8.计算到今天，你一共活了多少天
      String str1 = "2006.8.21";
      SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy.MM.dd");
      Date birth = sdf2.parse(str1);
      Date today = new Date();
      // today - birth
      long cha = today.getTime() - birth.getTime();
      // ** 单位换算
      long day = cha / (24 * 60 * 60 * 1000);  // 毫秒，转换为天
      System.out.println("一共活了" + day + "天");
   }
}

4.Calendar类

java.util.Calendar类，用于封装日历信息，包含了日期，主要用于操作时间分量。

Calendar是抽象类，可以通过其工厂方法获取到其子类的对象。

java.util.GregorianCalendar是Calendar的最主要使用的实现类，其对应世界上大多数国家/地区使用的标准日历。

4.1创建对象

    // 1. 创建对象(Calendar的对象中包含了当前日期。)
    Calendar c = Calendar.getInstance() ;// 调用工厂方法(静态方法)
    Calendar c1 = new GregorianCalendar(); //向上造型
    Calendar c3 = new GregorianCalendar(2008,8 , 8); // 指定日期
    Calendar birth = new GregorianCalendar(1900,10,5,3,5,20);

4.2获取时间分量：get

//Calendar --- 是抽象类
//提供了操作时间分量(向量)的get方法:
public class CalendarDemo1 {
   public static void main(String[] args) {
      //1.创建对象(Calendar 的对象中包含了当前日期)
      Calendar c = Calendar.getInstance(); // 调用工厂方法（静态方法）
      Calendar c1 = new GregorianCalendar(); //向上造型
      //2. 重写了toString方法
      System.out.println(c);
      //3.get方法
      System.out.println("年：" + c.get(Calendar.YEAR));
      System.out.println("月：" + (c.get(Calendar.MONTH) + 1));  // 月从0~11，代表1~12月
      System.out.println("日：" + c.get(Calendar.DATE));
      System.out.println("小时：" + c.get(Calendar.HOUR));  // 12小时制
      System.out.println("小时：" + c.get(Calendar.HOUR_OF_DAY)); // 24小时制
      System.out.println("分：" + c.get(12)); // Calendar.MINUTE  分 （Calendar.MINUTE = 12）
      System.out.println("秒：" + c.get(Calendar.SECOND));
      System.out.println("周几：" + c.get(Calendar.DAY_OF_WEEK)); // 周日是1， 周1 ~ 周6 是 2~7

      //练习： 把周几转换为日期的星期几
      int weekday = c.get(Calendar.DAY_OF_WEEK);
      System.out.println(weekday);
      String strweek = weekday == 1 ? "周日" : "周" + (weekday - 1);
      System.out.println(strweek);

      //4.**日历的getTime方法，得到Date类型
      Date d = c.getTime();
      //5．案例:输出指定的某年的每个月有多少天
      int m = c.getActualMaximum(Calendar.DAY_OF_MONTH);
      System.out.println(m);
   }
}

4.3修改时间分量：set

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class CalendarDemo2 {
   public static void main(String[] args) {
      // 5．案例:输出指定的某年的每个月有多少天
      Calendar c = Calendar.getInstance();
      c.set(Calendar.YEAR, 2000);
      System.out.println(c.get(Calendar.YEAR) + "年共有" + c.getActualMaximum(Calendar.DAY_OF_YEAR));
      //修改月份从0开始到11，表示1~12
      for (int i = 0; i < 12; i++) {
         c.set(Calendar.MONTH, i);
         int maxDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);  // 每月最大的天数
         System.out.println(c.get(Calendar.YEAR) + "年" + (i + 1) + "月" + maxDay + "天");
      }
      //6. 3年又100天，在母校欢聚，请问具体的聚会日期
      c = Calendar.getInstance();
      System.out.println("当前时间" + c.get(Calendar.YEAR) + "年" + (c.get(Calendar.MONTH) + 1) + "月" + c.get(Calendar.DATE) + "日");
      c.add(Calendar.YEAR, 3);
      c.add(Calendar.DATE, 100);
      Date c1 = c.getTime();
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
      System.out.println(sdf.format(c1));
      /*System.out.println("聚会时间" + c.get(Calendar.YEAR)+ "年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DATE)+"日");*/

      //7.计算2008.8.8
      c.set(2008, 8 - 1, 8);
      System.out.println(c.getTime());
      Date ou = c.getTime();
      System.out.println(ou);

      //8.创建日期
      GregorianCalendar c3 = new GregorianCalendar(2000, 1, 20);  //Calendar的一个实现类

      //9.时间毫秒数
      long timeInMillis = c3.getTimeInMillis();
      Date time = c3.getTime();  // Calendar 的getTime， 获取Date类型
      long time1 = time.getTime();  // Date的getTime， 获取时间毫秒数
      System.out.println(timeInMillis);
      System.out.println(time1);
   }
}

4.4增加时间分量：add

    //6. 3年又100天，在母校欢聚，请问具体的聚会日期
    c = Calendar.getInstance();
    System.out.println("当前时间" + c.get(Calendar.YEAR) + "年" + (c.get(Calendar.MONTH) + 1) + "月" + c.get(Calendar.DATE) + "日");
    c.add(Calendar.YEAR, 3);
    c.add(Calendar.DATE, 100);
    Date c1 = c.getTime();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    System.out.println(sdf.format(c1));

4.5时间毫秒数

//9.时间毫秒数
long timeInMillis = c3.getTimeInMillis();
Date time = c3.getTime();  // Calendar 的getTime， 获取Date类型
long time1 = time.getTime();  // Date的getTime， 获取时间毫秒数
System.out.println(timeInMillis);
System.out.println(time1);

5.基本数据类型的包装类

5.1基本数据类型和包装类的对应

8种基本数据类型，对应了8种包装类。每一个包装类封装了一个对应基本数据类型的成员变量，同时还提供了一些针对该类型操作的方法。

5.2自动装箱，自动拆箱

jdk5之后，基本数据类型和包装类的转换，依靠编译器的“预处理”完成。

//1.自动装箱，拆箱
Boolean b = true;
boolean b1 = b;

5.3包装类的常用方法

teger i = Integer.valueOf(5);
      Integer i1 = Integer.valueOf(10);

      //3.其他方法
      int i2 = i.compareTo(i1); //比较大小(如果i > i1 ,返回1，如果i== i1返回0 ，如果i< i1 ，返回-1)
      System.out.println(i2);
      float v = i.floatValue();
      double v1 = i.doubleValue(); // 类型转换
      boolean b2 = b.booleanValue(); // 包装类，转换为基本类型

      //5.parseInt , parseDouble
      //*** 如果字符串是不能转换的，则抛出异常
      String s = "3.1415";

      //6.进制转换
      String s1 = Integer.toBinaryString(100);
      System.out.println(s1);
      System.out.println(Integer.toOctalString(100));

      //7.Character
      Character c = Character.valueOf('a');
      char c1 = c.charValue();
      boolean letter = Character.isLetter(c);
   }
}

5.4基本数据类型和包装类的默认值不同

// ** 包装类和基本数据类型的默认值不同。
public class IntegerDemo1 {
   public static void main(String[] args) {
      Emp e = new Emp();
      System.out.println(e);
      Integer i1 = e.age;
      System.out.println(i1.toString()); // java.lang.NullPointerException， 应该尽量避免空指针异常
      Person p = new Person();
      System.out.println(p);
      Integer i = p.age;
      System.out.println(i.toString()); //调用对象就是调用对象本身的toString方法
   }
}

class Emp {
   Integer age;
   Double salary;
   String name;

   @Override
   public String toString() {
      return "Emp{" +
            "age=" + age +
            ", salary=" + salary +
            ", name='" + name + '\'' +
            '}';
   }
}

class Person {
   int age;
   double salary;
   String name;

   @Override
   public String toString() {
      return "Emp{" +
            "age=" + age +
            ", salary=" + salary +
            ", name='" + name + '\'' +
            '}';
   }
}

6.BigDecimal & BigInteger

6.1BigDecimal

java中的浮点数类型(float , double)在运算时会有舍入误差，如果希望得到精确的运算结果，可以使用java.math.BigDecimal类

6.2BigInteger

jdk中提供的整数类型(int ,long )的储值范围有限，当需要进行很大的整数运算时，可以使用java.math.BigInteger，理论上BigInteger数据范围只受内存容量的限定。
BigInteger提供了： add , subtract, multiply, divide等方法

7.集合

jdk中提供了将对象存储于特定数据结构的容器，被称为集合。

7.1Collection常用方法

//Collection 接口， 定义了集合的基本操作方法
//List 接口 extens Collection ， List在Collection的基础，提供了和List相关的方法
//ArraysList 类 ， 实现了List， 使用向上造型Collection c = new ArrayList(); 就可以使用Collection的方法。
public class CollectionDemo {
   public static void main(String[] args) {
      //1.创建对象
      Collection c = new ArrayList(); // 向上造型，编译看左边，运行看右边
      //2.添加元素
      c.add(1);
      c.add("A");
      c.add('b');
      c.add(3.5);
      //3.其他方法
      System.out.println("元素个数：" + c.size());
      System.out.println("是否为空：" + c.isEmpty());
      System.out.println("是否包含A：" + c.contains("A"));
      //重写了toString方法
      System.out.println("集合：" + c);
      boolean remove = c.remove(10);  // 删除了就true， 没有删除就false
      System.out.println("删除结果：" + remove);
      Collection c1 = new ArrayList();
      c1.add(2);
      c1.add(3);
      c1.add(4);
      //批量添加 -- 添加的是一个集合
      c.addAll(c1);
   }
}

7.2集合的遍历方式

	  // *** 使用Iterator 对 集合中的元素进行遍历。
      // *** iterator --迭代器
      // **w hasNext( ) -- 判断是否有下一个元素。如果有( true)就可以使用next( )函数获取到下一个元素。
      //                                     如果没有(false), while循环结束。
      System.out.println("----------------迭代器----------------");
      Iterator iterator = c.iterator();
      while (iterator.hasNext()) {
         System.out.println(iterator.next());
      }
      System.out.println("----------------匿名内部类----------------");
      c.forEach(new Consumer() {
         @Override
         public void accept(Object o) {
            System.out.println(o);
         }
      });

  System.out.println("----------------lambda表达式----------------");
  c.forEach((x) -> {
     System.out.println(x);
  }); //以后遍历要使用foreach加上lambda表达式

  System.out.println("添加集合之后：" + c);
  c.removeAll(c1);
  System.out.println("删除集合之后：" + c);
  c.clear();  // 清空集合的内容
  System.out.println("清空之后：" + c.isEmpty() + "---" + c.size());

7.3List

List接口的实现类实现了Collection接口。
List接口中根据线性表的数据结构定义了一些基于下标操作的方法。
List中增加了可以通过索引位置操作集合的相关方法(get ,set ,add ,remove等)

//Lists -- 接口
//ArrayList -- List的实习类
public class ListDemo {
   public static void main(String[] args) {
      //** 没有约束集合的元素类型，所以集合中可以添加任意类型
      //** 使用集合的时候，约束集合中的数据为某一组固定类型。（数据元素都放同一种类型）
      List list = new ArrayList();
      list.add(new Point());
      list.add(new Student());
      list.add("abcd");
      //** 调用forEach函数
      list.forEach((x) -> {

         Object d = x;
         if (d instanceof Point) {
            ((Point) d).show(); //强转，再调用方法。
         }
         if (d instanceof String) {
            System.out.println(((String) d).charAt(0));
         }
         if (d instanceof Student) {
            Student s = (Student) d;
         }
      });

      //使用泛型的语法规则：
      //List<Point> -- 约束集合中，只能存放Point类型
      List<Point> ps = new ArrayList<Point>();
      ps.add(new Point());
      ps.add(new Point());
      //ps.add(new Student()); // 编译错误： ps这个类型的泛型是Point， 所以只能添加Point类型的元素。
      ps.forEach((x -> {
         x.show();  // x就是Point类型。
      }));
   }
}

class Point {
   int x;
   int y;

   public void show() {
      System.out.println("point");
   }
}

class Student {
   int age;
   String name;

7.4集合中泛型的使用

声明引用和创建对象的时候，可以使用泛型的语法规则，约束集合的元素为指定类型。

public class ListDemo2 {
   public static void main(String[] args) {
      //1.练习： 创建一个List<Shape>的对象， 然后添加五个元素。
      List<Shape> list = new ArrayList<>();
      for (int i = 1; i <= 5; i++) {
         list.add(new Shape(i, i));
      }
      /*list.forEach((o)->{
         //o 就是循环遍历到的元素。
         System.out.println(o);
      });*/

      //3.List中和索引相关的函数
      //-- get(index) -- 取
      System.out.println(list.get(0));

      //-- set(index, object) -- 把指定位置的元素替换了
      list.set(0, new Shape(0, 0));
      System.out.println(list);

      //-- add(index, object)
      list.add(0, new Shape(5, 5));  // -- 在指定位置插入一个元素，其他元素就往后移动。
      System.out.println(list);

      //remove(Object o) , remove(index) -- 删除
      list.remove(list.size() - 1);  //删除最后一个
      System.out.println(list);

      //交换index 是2 和 index 是3 的位置
      Shape temp = list.get(2);
      list.set(2, list.get(3));
      list.set(3, temp);
      System.out.println(list);

      //集合中，是否包含（contains）某个元素： 以equals（重写后）的结果为准。
      Shape s = new Shape(4, 4);
      boolean contains = list.contains(s);
      System.out.println("是否包含：" + contains);

      //ArrayList 是有序（元素有添加的先后顺序）可重复的集合。
      list.add(s);
      System.out.println(list);
      list.sort((o1, o2) -> { // o1 ,o2 是集合中的元素。
         //return o1.x - o2.x;  // x大的在后面， -- 升序
         return -(o1.x - o2.x);   // 降序
      });
      System.out.println(list);

      //练习:把集合中的元素的x ,y ，都增加一个随机数，然后再排序(升序)
      Random r = new Random();
      list.forEach((shape) -> {
         shape.x = shape.x + r.nextInt(10);
         shape.y = shape.y + r.nextInt(10);
      });
      System.out.println("排序前：" + list);
      list.sort((o1, o2) -> {
         return -(o1.x - o2.x);  //-(o1.x - o2.x):降序， sort方法默认是升序
         //return o1.y - o2.y;
      });
      System.out.println("排序h后：" + list);
   }
}

class Shape {
   int x;
   int y;

   public Shape() {
   }

   public Shape(int x, int y) {
      this.x = x;
      this.y = y;
   }

   @Override
   public String toString() {
      return "Shape(" +
            x + "," + y +
            ')';
   }

   @Override
   public boolean equals(Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;
      Shape shape = (Shape) o;
      return x == shape.x && y == shape.y;
   }

   @Override
   public int hashCode() {
      return Objects.hash(x, y);
   }
}

8. 练习

//倒计时，每隔1秒显示，距离2024.1.1 0：0：0还有多少天，小时，分钟，秒。
public class home {
   public static String getTime() {
      Calendar c = Calendar.getInstance(); // 调用工厂方法
      Calendar c1 = new GregorianCalendar(2024, 0, 1, 0, 0, 0); //初始化时间2024.1.1 0：0：0
      long l = c1.getTimeInMillis() - c.getTimeInMillis(); //时间毫秒数之差
      long day = l / (24 * 60 * 60 * 1000);   // 天
      long hour = l / (60 * 60 * 1000) % 24;  // 小时
      long minute = l / (60 * 1000) % 60;     // 分
      long second = l / (1000) % 60;          // 秒

      return "距离2024.1.1 0：0：0还有," + day + "天" + "，" + hour + "小时" + "，" + minute + "分钟" + "，" + second + "秒";
   }

   public static void main(String[] args) {
      Timer timer = new Timer(); //定时任务
      timer.schedule(new TimerTask() { // 匿名内部类
         @Override
         public void run() {
            //System.out.println("该睡觉了");
            System.out.println(getTime());
         }
      }, 1000, 1000);  // 延时一秒执行， 执行间隔时间为1秒
   }
}

A码

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
java SE_3

本篇文章主要介绍了Java中的集合（Collection）和常见的包装类（例如Integer、BigDecimal、BigInteger）的用法，以及日期和时间处理类（Date、SimpleDateFormat、Calendar）的基本操作。此外，还包括了链式操作的概念和示例代码。文章还提供了一个倒计时示例，用于显示距离指定日期还有多少天、小时、分钟和秒。文章涵盖了集合的基本操作、遍历方式、List的详细使用方法，以及泛型的应用。此外，还包括了对包装类和日期处理类的介绍，以及示例代码展示了如何使用这些类
复制链接

扫一扫