Java入门

文章目录

JAVA基础

一、java开发步骤二、注释三、第一个java程序四、转义序列五、变量、数据类型和运算符

1.变量2.基本数据类型3.运算符4.运算符优先级5.类型转换6.从控制台接收用户输入值 六、条件语句

1.if...else2.if...else if...else3.嵌套的 if…else 语句4.switch选择结构 七、循环结构

1.while :2.do...while:3.for: 执行的次数是在执行前就确定的4.用于数组的for循环5.关键字6.断点调试 八、Number类&Math类

1.Number类2.Math类3.Number&Math类方法 九、Character 类十、String类

1.String2.StringBuffer3.String、StringBuffer和StringBuilder类的区别 十一、数组

1.一维数组2.二维数组3.Arrays类 十二、ArrayList<>

1.ArrayList类

①添加元素:sites.add(val)②访问元素:sites.get(index)③修改元素:site.set(index,val)④删除元素:sites.remove(index)⑤计算大小(元素数量):sites.size()⑥迭代数组列表: 2.ArrayList引用类型3.ArrayList排序4.ArrayList方法 十三、时间日期date（）

JAVA基础 一、java开发步骤

编写源代码(.java)

编译,生成字节码文件(.class)

javac hello.java

运行程序

java hello

二、注释

单行注释:ctrl+/

// 单行注释

多行注释: ctrl+shift+/

文档注释:

 
    public static int sum(int num1,int num2){
        int sum=num1+num2;
        return sum;
    }

三、第一个java程序

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

四、转义序列

前面有反斜杠（）的字符代表转义字符，它对编译器来说是有特殊含义的。

转义序列	描述
t	在文中该处插入一个tab键
b	在文中该处插入一个后退键
n	在文中该处换行
r	在文中该处插入回车
f	在文中该处插入换页符
’	在文中该处插入单引号
"	在文中该处插入双引号
	在文中该处插入反斜杠

五、变量、数据类型和运算符 1.变量

声明变量：

数据类型 变量名=初始值；数据类型 变量名； 变量名=值；

int x=1;
int y;
y=2;
int sum=x+y;
String str=null;

变量不但可以重新赋值,还可以赋值给其他变量

int x=1;	
x+=1;
int y=x;

变量命名规则:

只能包含字母/数字/下划线/$不能以数字开头小写开头,驼峰式命名(userName)见名知意 成员变量和局部变量:

作用域不同:

成员变量作用域在整个类中局部变量作用域仅限于定义方法内 初始值不同

成员变量创建会被赋予一个初始值局部变量不会被赋予初始值 同一方法中,不允许有同名局部变量在不同方法中,可以有同名局部变量同一类中,成员变量和局部变量同名时,局部变量优先级更高 2.基本数据类型

整数类型：byte，short，int，long

浮点数类型：float，double

字符类型：char

布尔类型：boolean

int i = 2147483647;
long l=900000000000000L //long,需要加L后缀 
float f1=3.14f          //float类型后要加f
double d=1.79e308
boolean b1=true        //布尔值只有true和false两个值
boolean b2=false
boolean isGreater=5>3  //计算结果为Ttre
char en = 'A'   //char只能存放一个字符,使用单引号''
char zh = '中'

引用类型:除了上述基本类型的变量,剩下都是引用类型,如String字符串

String str="string字符串"

常量:在定义变量前加入final,变为常量不可重新赋值(常量名通常全部大写)

final double PI=3.14 //PI变为常量,重新赋值会报错

3.运算符

算术运算符

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
–	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文）

自增自减运算符:

自增（++）自减（–）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算。后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算

关系运算符(结果是boolean类型)

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

位运算符

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001

逻辑运算符

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

赋值运算符

条件运算符( 三元运算符 )

//变量=(表达式)?条件1(表达式为true):条件2(表达式为flase)
x = (expression) ? value if true : value if false 

4.运算符优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8K9FuSN0-1646579551169)(images/运算符优先级.png)]

5.类型转换

强制类型转换: (数据类型) 表达式

int a=(int) 10.2;
double b=10;
int c=(int)b

自动类型转换:

两种类型要兼容(整型和浮点型)目标类型大于源类型(double型大于int型)如果一个操作数为double型,整个表达式可提升为double型

String转换为int:

Integer.parseInt(str);
Integer.value(str).intValue();

int 转换为String:

String.valueOf(num);
Integer.toString(num);
num+" "

6.从控制台接收用户输入值

创建scanner对象

输入提示问题

变量接收值

Scanner input=new Scanner(System.in);
System.out.print("请输入:");
String str=input.next();

六、条件语句 1.if…else

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

2.if…else if…else

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

3.嵌套的 if…else 语句

if(布尔表达式 1){
   如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      如果布尔表达式 2的值为true执行代码
   }else(布尔表达式 3){
       如果布尔表达式 3的值为true执行代码
   }    
}else(布尔表达式 4){
     如果布尔表达式 4的值为true执行代码
}

4.switch选择结构

(表达式包括int、short、byte、char、枚举、String类型)

switch (表达式){
            case 常量1:
                //执行语句1
                break;
            case 常量2:
                //执行语句2
                break;
            case 常量3:
    		case 常量4:	
                //3、4都执行语句3
                break;
            default:
                //没有找到匹配值执行语句
                break;
        }

*退出程序:不再向下执行

System.exit(0);

七、循环结构 1.while :

只要布尔表达式为 true，循环就会一直执行下去。

while( 布尔表达式 ) {
  //循环内容
}

2.do…while:

即使不满足布尔表达式也会执行一次循环

do {
       //代码语句
}while(布尔表达式);

3.for: 执行的次数是在执行前就确定的

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

4.用于数组的for循环

//声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
//表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
for(声明语句 : 表达式)
{
   //代码句子
}

例如:

int[] num={1,2,3,4}
for(int i:num){
    System.out.print( x );
    System.out.print(",");
}

5.关键字

break关键字:

在循环语句或者 switch 语句中，跳出整个语句块。

跳出最里层的循环，继续执行该循环下面的语句。

continue关键字:

适用于任何循环控制结构中。立刻跳转到下一次循环的迭代。在 for 循环中，使程序立即跳转到更新语句。在 while 或者 do…while 循环中，立即跳转到布尔表达式的判断语句。

例:

public class Test {
   public static void main(String[] args) {
      int [] numbers = {10, 20, 30, 40, 50};
      for(int x : numbers ) {
         if( x == 30 ) {
        continue;
         }
         System.out.print( x );
         System.out.print("n");
      }
   }
}

6.断点调试

设置断点debug运行在断点后fn +F9,一步步运行查看变量和程序运行

八、Number类&Math类 1.Number类

当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。

然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类**（Integer、Long、Byte、Double、Float、Short）**都是抽象类 Number 的子类。

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cqg28xMg-1646579551170)(images/Number类.png)]

由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

public class Test{
 //当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。
   public static void main(String[] args){
      Integer x = 5;
      x =  x + 10;
      System.out.println(x); 
   }
}

2.Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

3.Number&Math类方法

序号	方法与描述	描述	语法
1	xxxValue()	将 Number 对象转换为xx数据类型的值并返回。	.doublevalue()
2	compareTo()	将number对象与(同类型)参数比较。(小于返回-1,大于返回1,相等返回0)	x.compareTo(3)
3	equals()	判断number对象是否与参数相等。	x.equals(y)
4	valueOf()	返回一个 Number 对象指定的内置数据类型	**Integer valueOf(int i)：**返回一个表示指定的 int 值的 Integer 实例。**Integer valueOf(String s)*返回保存指定的 String 的值的 Integer 对象。Integer valueOf(String s, int radix): 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。
5	toString()	以字符串形式返回值。	x.toString()
6	parseInt()	将字符串解析为int类型。	int x =Integer.parseInt(“9”);
7	abs()	返回参数的绝对值。(任何原生数据类型)	Math.abs(x)
8	ceil()	返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。	Math.ceil(x)
9	floor()	返回小于等于（<=）给定参数的最大整数 。	Math.floor(x)
10	rint()	返回与参数最接近的整数。返回类型为double。	Math.rint(x)
11	round()	它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。	Math.round(x)
12	min()	返回两个参数中的最小值。	Math.min(x,y)
13	max()	返回两个参数中的最大值。	Math.max(x,y)
14	exp()	返回自然数底数e的参数次方。	Math.exp(x)
15	log()	返回参数的自然数底数的对数值	Math.log(x)
16	pow()	返回第一个参数的第二个参数次方。	Math.pow(x, y)
17	sqrt()	求参数的算术平方根。	Math.sqrt(x)
18	sin()	求指定double类型参数的正弦值。	Math.sin(x)
19	cos()	求指定double类型参数的余弦值。	Math.cos(x)
20	tan()	求指定double类型参数的正切值。	Math.tan(x)
21	asin()	求指定double类型参数的反正弦值。	Math.asin(x)
22	acos()	求指定double类型参数的反余弦值。	Math.acos(x)
23	atan()	求指定double类型参数的反正切值。	Math.atan(x)
24	atan2()	将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。	Math.atan2(x)
25	toDegrees()	将参数转化为角度。	Math.toDegrees(x)
26	toRadians()	将角度转换为弧度。	Math.toDegrees(x)
27	random()	返回一个随机数。 范围:(0.0-1.0)	Math.random()

九、Character 类

Character类提供了一系列方法来操纵字符。你可以使用Character的构造方法创建一个Character类对象

方法：

序号	方法与描述
1	isLetter() 是否是一个字母
2	isDigit() 是否是一个数字字符
3	isWhitespace() 是否是一个空白字符
4	isUpperCase() 是否是大写字母
5	isLowerCase() 是否是小写字母
6	toUpperCase() 指定字母的大写形式
7	toLowerCase() 指定字母的小写形式
8	toString() 返回字符串形式，长度仅为1

十、String类 1.String

创建方式：

String str = "Runoob";
//构造函数
String str2=new String("Runoob");


//提供数组参数  结果为runnoob
public class StringDemo{
   public static void main(String args[]){
      char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

获取字符串长度:

String str=new String("str")
int len=str.length();  //3

连接字符串

//concat()方法
string1.concat(string2);
// '+'连接
"hello,"+"world!";

字符串格式化-String.format()

含义：创建格式化的字符串以及连接多个字符串对象。显示不同转换符实现不同数据类型到字符串的转换，如图所示。

转 换 符	说 明
%s	字符串类型
%c	字符类型
%b	布尔类型
%d	整数类型（int）
%f	浮点类型
%n	换行符
%%	百分比类型

String str=null;
str=String.format("Hi,%s", "王力");
System.out.println(str);
str=String.format("Hi,%s:%s.%s", "王南","王力","王张"); System.out.println(str);

Scanner input=new Scanner(System.in);
System.out.print("请输入第一个数:");
int num1=input.nextInt();
System.out.print("请输入第二个数:");
int num2=input.nextInt();
boolean isbiger=num1>num2;
System.out.printf("num1:%d > num2:%d is %b",num1,num2,isbiger);

日期和时间字符串格式化

Date date = new Date();

// %c 输出全部日期是事件信息
System.out.printf("全部日期和时间信息：%tc%n",date);  
// %F 输出年-月-日
System.out.printf("年-月-日格式：%tF%n",date);

 // %T 输出时间
System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);

大小写转换:

//非字母不受影响
str.toLowerCase(); //小写
str.yoUpperCase(); //大写

去除字符串中空格:

str.trim();

str = str.replace((char) 12288, ' ');    // 将中文空格替换为英文空格
str = str.trim();

截取字符串:

//1. substring(int beginindex)
String str = "我爱 Java 编程";
String result = str.substring(3);
System.out.println(result);    // 输出：Java 编程
//2. substring(int beginIndex，int endIndex) 
//(起始位置从0开始计算,结束为止从1开始计算)

//截取新闻标题

public static void main(String[] args) {
    // 定义存储新闻标题的数组
    String[] news = new String[] { "如何快速掌握Java", "听老王剖析Java中的运算符", "学习Java的十大忠告", "你所不知道的java网络编程技巧大全", "Java面试题大全" }; 
    String title = "************* 新闻列表 *************";
    System.out.println(title.substring(10, 30));
    System.out.println("----------------------------------------------");
    
    for (int i = 0; i < news.length; i++) {
        // 判断数组元素的长度是否大于10，如果大于，则截取，否则全部显示
        if (news[i].length() > 10) {
            System.out.println(news[i].substring(0, 10) + "…");
        } else {
            System.out.println(news[i]);
        }
    }
}

分隔字符串

//sign为指定分隔符,可以是任意字符串 limit(可选)限制生成字符串限制个数
str.split(String sign);
str.split(String sign,int limit);
//使用("." "|")转义字符作为作为分割符,必须加"\"
//有多个分割符,可以用"|"作为连字符,比如：“acount=? and uu =? or n=?”，把三个都分隔出来，可以用String.split("and|or")。
//当指定分割字符串后组成的数组长度（大于或等于 1）时，数组的前几个元素为字符串分割后的前几个字符，而最后一个元素为字符串的剩余部分

字符串替换:

replace(): 将目标字符串中的指定字符（串）替换成新的字符(串)

//oldchar表示要替换的字符(串) newchar表示替换后的字符(串)
str.replace(String oldChar, String newChar);

replaceFirst(): 将目标字符串中匹配某正则表达式的第一个子字符串替换成新的字符串

//regex表示增则表达式,replacement表示用于替换的字符串
str.replaceAll(String regex, String replacement)

replaceAll(): 将目标字符串中匹配某正则表达式的所有子字符串替换成新的字符串

//regex表示增则表达式,replacement表示用于替换的字符串
str.replaceAll(String regex, String replacement)

例:

//1.replace()
String words = "hello java,hello php";
System.out.println("replace("hello","你好")结果："+words.replace("hello","你好 "));
//2.replaceFirst()  
String words = "hello java，hello php";
String newStr = words.replaceFirst("hello","你好 ");
System.out.println(newStr);    // 输出：你好 java,hello php
//3.replaceAll()
String words = "hello java，hello php";
String newStr = words.replaceAll("hello","你好 ");
System.out.println(newStr);    // 输出：你好 java,你好 php

字符串比较:

equals() ： 逐个地比较两个字符串的每个字符是否相同 (区分大小写)

str1.equals(str2);
//如果两个字符串具有相同的字符和长度，它返回 true，否则返回 false。对于字符的大小写，也在检查的范围之内

equalsIgnoreCase() :逐个地比较两个字符串的每个字符是否相同 (不区分大小写)

str1.equalsIgnoreCase(str2)

compareTo() : 按字典顺序比较两个字符串的大小,基于字符串各个字符的 Unicode 值

str1.compareTo(str2);
//如果按字典顺序 str1 位于 str2 参数之前，比较结果为一个负整数；如果 str1 位于 str2 之后，比较结果为一个正整数；如果两个字符串相等，则结果为 0。

字符串查找:

①根据字符查找

indexOf(): 返回字符（串）在指定字符串中首次出现的索引位置

//如果能找到，则返回索引值，否则返回 -1 
//value 表示待查找的字符（串）；fromIndex表示查找时的起始索引，如果不指定 ，则默认从指定字符串中的开始位置开始查找。
str.indexOf(value,int fromIndex)

lastlndexOf() : 返回字符（串）在指定字符串中最后一次出现的索引位置

//如果能找到则返回索引值，否则返回 -1
//从右往左查找，如果不指定起始索引，则默认从字符串的末尾开始查找。
str.lastlndexOf(value, int fromIndex)

② 根据索引查找

charAt() : 在字符串内根据指定的索引查找字符

index表示索引值,从0开始
str.charAt(index)

2.StringBuffer

StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大。

构造方法:

//1.构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。
StringBuffer str1 = new StringBuffer();
//2.创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
StringBuffer str2 = new StringBuffer(int length);
//3.创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。
StringBuffer str3 = new StringBuffer(String str);

返回字符串容量大小:capacity()

//查看StringBuffer对象的容量大小
System.out.println(str1.capacity());

追加字符串: append()

//向原有 StringBuffer 对象中追加字符串到末尾
StringBuffer str1 = new StringBuffer();
str1.append(str2)

替换字符: setCharAt()

//在字符串的指定索引位置替换一个字符
//index表示要修改位置的索引,从零开始  ch表示要修改的字符
str1.setCharAt(int index, char ch);

反转字符串: reverse()

//将字符串序列用其反转的形式取代
str.reverse();

删除字符串:

deleteCharAt(): 移除序列中指定位置的字符

删除指定位置的字符，然后将剩余的内容形成一个新的字符串
str.deleteCharAt(int index);

delete(): 移除序列中子字符串的字符

//删除[start,end)范围内的所有字符(包括start,不包括end)
str.delete(int start,int end);

3.String、StringBuffer和StringBuilder类的区别

String 类是不可变类（ 被创建以后，包含在这个对象中的字符序列是不可改变的 ）StringBuffer 和 StringBuilder 是可变类StringBuilder 和 StringBuffer 功能基本相似，方法也差不多。不同的是，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此在通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用 StringBuilder 类。速度从快到慢为 StringBuilder > StringBuffer > String操作少量的数据使用 String。
单线程操作大量数据使用 StringBuilder。
多线程操作大量数据使用 StringBuffer。

十一、数组 1.一维数组

定义:数据类型[] 数组名=new 数据类型[数组长度];

int[] scores=new int[5];

数组元素分配的初始值:

数组元素类型	默认初始值
int	0
double	0.0
char	‘u0000’
boolean	false
String	null

数组元素的表示与赋值

//数组元素在数组里顺序排列编号,即为元素下标,收元素编号为0
scores[0];
//赋值
scores[0]=65;

初始化数组:

数据类型[] 数组名={v1,v2…,vn};数据类型[] 数组名=new 数据类型[]{v1,v2…,vn}

int scores[]={1,2,3,4,5} //长度为5的数组scores
int scores[]=new int[]{1,2,3,4,5}

遍历数组:数组和循环结合使用(通常使用for循环)

创建整型数组创建Scanner对象将循环变量i作为数组下标,循环接收键盘输入,为数组元素赋值

//创建数组并通过循环为数组元素赋值
int scores[]=new int[5];
Scanner sc=new Scanner(System.in);
for(int i=0;i 

2.二维数组

定义方法:数据类型 数组名 [] []

int[][] s=new int[3][5];(三个数组,每组5个元素)
//初始化
int[][] scores=new int{{90,79,80},{49,23},{20}}

遍历二维数组:

int[][] scores=new int{{88,78},{90,89},{78,98,90}};
int total=0;
for(int i=0;i 

3.Arrays类

常用方法:

方法	返回类型	说明
equals(arr1,arr2)	boolean	比较两个数组是否相等
sort(arr)	void	对数组进行升序排列
toString(arr)	String	将数组转换成一个字符串
fill(arr,val)	void	将数组中素有元素赋值为val
copyOf(arr,length)	与arr数据类型一致	将数组复制成长度为len的新数组
binarySearch(arr,val)	int	查询元素值val在数组中下标(必须是顺序列表)

//1.equals(arr1,arr2) 判断两个数组长度和元素是否相等
        int[] arr1={10,50,20,30};
        int[] arr2={10,50,20,30};
        int[] arr3={60,34,23};
        System.out.println(Arrays.equals(arr1,arr2)); 
        //判断arr1与arr2长度与元素是否相等
        System.out.println(Arrays.equals(arr2,arr3)); 
        //判断arr2与arr3长度与元素是否相等

//2.sort(arr)  对数组进行升序排序
        int[][] array=new int[][]{{80,70},{78,98,90},{78,87,98,79}};
        for(int i=0;i 

十二、ArrayList<> 1.ArrayList类

一个可以动态修改的数组，没有固定大小的限制，可以添加或删除元素。

初始化：数据类型只能为引用数据类型

import java.util.ArrayList; // 引入 ArrayList 类

ArrayList objectName =new ArrayList<>();　 // 初始化
//E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
//objectName: 对象名。

ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

①添加元素:sites.add(val)

ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites);

②访问元素:sites.get(index)

ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
System.out.println(sites.get(1));  // 访问第二个元素

③修改元素:site.set(index,val)

ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
System.out.println(sites);

④删除元素:sites.remove(index)

ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
sites.remove(3); // 删除第四个元素
System.out.println(sites);

⑤计算大小(元素数量):sites.size()

ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites.size());

⑥迭代数组列表:

for循环

ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
for (int i = 0; i < sites.size(); i++) {
   System.out.println(sites.get(i));
}

for-each

ArrayList sites = new ArrayList();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
for (String i : sites) {
    System.out.println(i);
}

2.ArrayList引用类型

ArrayList 中的元素实际上是对象，在以上实例中，数组列表元素都是字符串 String 类型。

要存储其他类型，而 只能为引用数据类型，需要使用到基本类型的包装类。

基本类型对应的包装类表如下:

基本类型	引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

例如:

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList myNumbers = new ArrayList();
        myNumbers.add(10);
        myNumbers.add(15);
        myNumbers.add(20);
        myNumbers.add(25);
        for (int i : myNumbers) {
            System.out.println(i);
        }
    }
}

3.ArrayList排序

Collections 类位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序

import java.util.ArrayList;
import java.util.Collections;  // 引入 Collections 类

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList myNumbers = new ArrayList();
        myNumbers.add(33);
        myNumbers.add(15);
        myNumbers.add(20);
        myNumbers.add(34);
        myNumbers.add(8);
        myNumbers.add(12);

        Collections.sort(myNumbers);  // 数字排序

        for (int i : myNumbers) {
            System.out.println(i);
        }
    }
}

4.ArrayList方法

方法	描述	语法
add()	将元素插入到指定位置的 arraylist 中	arraylist.add（index,val） index:可选,指定插入处索引值
addAll()	添加集合中的所有元素到 arraylist 中	arraylist.addAll(index, arraylist2) index:可选,指定插入处索引值
clear()	删除 arraylist 中的所有元素	arraylist.clear()
clone()	复制一份 arraylist(浅拷贝)	ArrayList cloneSites =(ArrayList)sites.clone();
contains()	判断元素是否在 arraylist	arraylist.contains(val) //返回值 boolean
get()	通过索引值获取 arraylist 中的元素	arraylist.get(index)
indexOf()	返回 arraylist 中元素的索引值	arraylist.indexOf(val)
removeAll()	删除存在于指定集合中的 arraylist 里的所有元素	arraylist.removeAll(arraylist);
remove()	删除 arraylist 里的单个元素	指定元素:arraylist.remove(val) 指定索引的元素 :arraylist.remove(index)
size()	返回 arraylist 里元素数量	arraylist.size()
isEmpty()	判断 arraylist 是否为空	arraylist.isEmpty()
subList()	截取部分 arraylist 的元素(前闭后开)	arraylist.subList(fromIndex, oIndex)
set()	替换 arraylist 中指定索引的元素	arraylist.set(index, val)
sort()	对 arraylist 元素进行排序	arraylist.sort(Comparator.naturalOrder()); 升序:naturalOrder 降序:reverseOrder
toArray()	将 arraylist 转换为数组	arraylist.toArray(arr)
toString()	将 arraylist 转换为字符串	arraylist.toString()
ensureCapacity()	设置指定容量大小的 arraylist() 马上调整为指定的容量大小,超出会自动调整大小	arraylist.ensureCapacity(minCapacity)
lastIndexOf()	返回指定元素在 arraylist 中最后一次出现的位置	arraylist.lastIndexOf(val)
retainAll()	保留指定集合中也存在的元素(删除不存在)	arraylist.retainAll(arraylist2);
trimToSize()	将 arraylist 中的容量调整为数组中的元素个数	arraylist.trimToSize(); (没有返回值，仅更改 arraylist 的容量)
containsAll()	查看 arraylist 是否包含指定集合中的所有元素	arraylist.containsAll(arrlist2);
removeRange()	删除 arraylist 中指定索引之间存在的元素	arraylist.removeRange( from, to)
replaceAll()	将给定的操作内容替换掉数组中每一个元素	arraylist.replaceAll(e -> e.toUpperCase()) numbers.replaceAll(e -> e * 2);
removeIf()	删除所有满足特定条件的 arraylist 元素	arraylist.removeIf(Predicate filter)
forEach()	遍历 arraylist 中每一个元素并执行特定操作	arraylist.forEach(Consumer action)

十三、时间日期date（）

初始化：

// 初始化 Date 对象
Date date = new Date();
// 使用 toString() 函数显示日期时间
System.out.println(date.toString());
//使用 SimpleDateFormat 格式化日期
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
System.out.println(ft.format(date));