Java String类

一、创建字符串

1、简单方式：String str = "seventeen";
2、用构造函数创建字符串：String str2=new String("seventeen");

• String创建的字符串存储在公共池中，而new创建的字符串对象在堆上
• String类是不可改变的，所以一旦创建了String对象，那它的值就无法改变了
• 如果需要对字符串做很多修改，那么应该选择使用StringBuffer & StringBuilder类

二、字符串长度

1、访问器方法：用于获取有关对象的信息的方法
2、length()方法：返回字符串对象包含的字符数

三、连接字符串

1、string1.concat(string2);
返回string2连接string1的新字符串。也可以对字符串常量使用 concat()方法
"Say the name ".concat("seventeen");
2、用'+'操作符来连接字符串
"Say the name " + "seventeen" + "!"

四、创建格式化字符串

1、输出格式化数字可以使用printf()和format()方法
2、String类的静态方法format()能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

五、String方法（列举部分，遇到其他方法可再添加）

六、StringBuffer和StringBuilder类

当对字符串进行修改的时候，需要使用StringBuffer和 StringBuilder类。和String类不同的是，StringBuffer和 StringBuilder类的对象能够被多次的修改，并且不产生新的未使用对象

Java数组

一、声明数组变量

dataType[] arrayRefVar;   // 首选的方法
或
dataType arrayRefVar[];  // 效果相同，但不是首选方法

二、创建数组

1、使用new操作符来创建数组
arrayRefVar = new dataType[arraySize];

• 使用 dataType[arraySize]创建了一个数组
• 把新创建的数组的引用赋值给变量arrayRefVar

2、数组变量的声明，和创建数组可以用一条语句完成
dataType[] arrayRefVar = new dataType[arraySize];
3、其他方式创建数组
dataType[] arrayRefVar = {value0, value1, ..., valuek};
数组的元素是通过索引访问的。数组索引从0开始，所以索引值从 0到arrayRefVar.length-1
4、实例

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

总和为： 11367.373

三、处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，通常使用基本循环或者For-Each循环
1、基本循环实例

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

2、For-Each循环（加强型循环）
（1）在不使用下标的情况下遍历数组，语法格式如下：

for(type element: array)
{
    System.out.println(element);
}

（2）实例

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

1.9
2.9
3.4
3.5

四、数组作为函数的参数

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}
printArray(new int[]{3, 1, 2, 6, 4, 2});

五、数组作为函数的返回值

//数组转置输出
public static int[] reverse(int[] list) {
        int[] result = new int[list.length];

        for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
            result[j] = list[i];
        }
        printArray(result);//调用函数输出result数组
        return result;
    }

** 遇到的问题**：在主函数中调用reverse没有输出result数组
解决方法：需要调用printArray()输出result数组

六、多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
String[][] str = new String[3][4];
1、多维数组初始化的动态
type[][] typeName = new type[typeLength1][typeLength2];
（1）type可以为基本数据类型和复合数据类型，typeLength1和 typeLength2必须为正整数，typeLength1为行数，typeLength2 为列数
（2）从最高维开始，分别为每一维分配空间

String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

s[0]=new String[2]和s[1]=new String[3]是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间s0=new String("Good")等操作
2、多维数组的引用
arrayName[index1][index2]

七、Arrays类（随时补充其他方法或具体方法的描述）

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

• 给数组赋值：通过fill方法
• 对数组排序：通过sort方法,按升序
• 比较数组：通过equals方法比较数组中元素值是否相等
• 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

Java日期时间

java.util包提供了Date类来封装当前的日期和时间。Date类提供两个构造函数来实例化Date对象。

• 第一个构造函数使用当前日期和时间来初始化对象。
  Date( )
• 第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数
  Date(long millisec)

一、Date对象创建后的调用方法

二、获取当前时间

import java.util.Date;
  
public class DateDemo {
   public static void main(String[] args) {
       // 初始化 Date 对象
       Date date = new Date();
        
       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());
   }
}

Tue Aug 13 09:13:12 CST 2024

三、使用SimpleDateFormat格式化日期

SimpleDateFormat允许选择任何用户自定义日期时间格式来运行

import  java.util.*;
import java.text.*;
 
public class DateDemo {
   public static void main(String[] args) {
 
      Date dNow = new Date( );
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
 
      System.out.println("当前时间为: " + ft.format(dNow));
   }
}

当前时间为: 2024-08-13 09:25:25
其中yyyy是完整的公元年，MM是月份，dd是日期，HH:mm:ss是时、分、秒。有的格式大写，有的格式小写，例如MM是月份，mm是分；HH是24小时制，而hh是12小时制。

四、日期和时间的格式化编码

1、使用printf格式化日期

• %tY：输出四位数的年份，例如：2023
• %ty：输出两位数的年份，例如：23
• %tm：输出两位数的月份，例如：02
• %tB：输出月份的全名，例如：February
• %tb：输出月份的缩写，例如：Feb
• %tA：输出星期的全名，例如：Wednesday
• %ta：输出星期的缩写，例如：Wed
• %td：输出两位数的日期，例如：24
• %te：输出一位或两位数的日期，例如：24或02
• %tH：输出24小时制的小时数，例如：23
• %tI：输出12小时制的小时数，例如：11
• %tM：输出分钟数，例如：45
• %tS：输出秒数，例如：30
• %tp：输出上午还是下午，例如：AM或PM
• %tZ：输出时区，例如：GMT+08:00

import java.util.Date;
public class DateFormatExample {
   public static void main(String[] args) {
      Date date = new Date();
      System.out.printf("%tY-%tm-%td %tH:%tM:%tS %tZ", date, date, date, date, date, date, date);
   }
}

2024-08-13 09:47:59 CST

2、如果需要重复提供日期，那么利用这种方式来格式化它的每一部分就有点复杂了。因此，可以利用一个格式化字符串指出要被格式化的参数的索引。索引必须紧跟在%后面，而且必须以$结束。或者可以使用<标志。它表明先前被格式化的参数要被再次使用。
3、解析字符串为时间（ ？）
SimpleDateFormat类有一些附加的方法，特别是parse()，它试图按照给定的SimpleDateFormat对象的格式化存储来解析字符串

五、Java休眠

sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。

import java.util.*;
  
public class SleepDemo {
   public static void main(String[] args) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(1000*3);   // 休眠3秒
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) { 
          System.out.println("Got an exception!"); 
      }
   }
}

Thu Sep 17 10:20:30 CST 2015

Thu Sep 17 10:20:33 CST 2015

六、测量时间

测量时间间隔实例

import java.util.*;
  
public class DiffDemo {
 
   public static void main(String[] args) {
      try {
         long start = System.currentTimeMillis( );//返回当前计算机时间
         System.out.println(new Date( ) + "\n");
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

Tue Aug 13 14:49:08 CST 2024

Tue Aug 13 14:49:11 CST 2024

Difference is : 3036

七、Galendar类

设置和获取日期数据的特定部分，比如说小时，日，或者分钟，或在日期的这些部分加上或者减去值。
1、创建一个代表系统当前日期的Calendar对象
Calendar c = Calendar.getInstance();//默认是当前日期
2、创建一个指定日期的Calendar对象

//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);

3、Calendar类对象信息的设置
（1）Set设置
Calendar c1 = Calendar.getInstance();
调用：
public final void set(int year,int month,int date)
c1.set(2009, 6, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12

• 如果只设定某个字段，例如日期的值，则可以使用如下set方法

public void set(int field,int value)
把c1对象代表的日期设置为10号，其它所有的数值会被重新计算
c1.set(Calendar.DATE,10);
把c1对象代表的年份设置为2008年，其他的所有数值会被重新计算
c1.set(Calendar.YEAR,2008);
（2）Add设置
Calendar c1 = Calendar.getInstance();
把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);

八、GregorianCalendar类

GregorianCalendar是Calendar类的一个具体实现

import java.util.*;
  
public class GregorianCalendarDemo {
 
   public static void main(String[] args) {
      String months[] = {
      "Jan", "Feb", "Mar", "Apr",
      "May", "Jun", "Jul", "Aug",
      "Sep", "Oct", "Nov", "Dec"};
      
      int year;
      // 初始化 Gregorian 日历
      // 使用当前时间和日期
      // 默认为本地时间和时区
      GregorianCalendar gcalendar = new GregorianCalendar();
      // 显示当前时间和日期的信息
      System.out.print("Date: ");
      System.out.print(months[gcalendar.get(Calendar.MONTH)]);
      System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
      System.out.println(year = gcalendar.get(Calendar.YEAR));
      System.out.print("Time: ");
      System.out.print(gcalendar.get(Calendar.HOUR) + ":");
      System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
      System.out.println(gcalendar.get(Calendar.SECOND));
      
      // 测试当前年份是否为闰年
      if(gcalendar.isLeapYear(year)) {
         System.out.println("当前年份是闰年");
      }
      else {
         System.out.println("当前年份不是闰年");
      }
   }
}

Date: Aug 13 2024
Time: 3:13:16
当前年份是闰年