枚举、包装类和String类

培养ctrl+s 习惯
枚举
1.1枚举产生的原因
比如你的性别只能是男女，不能定义别的，这时候就需要枚举了

关键字： enum

1.2创建枚举：

public enum Gender { //class 换成 枚举enum
	MAN,WOMAN //不建议用中文 一般都是大写或首字母大写
}

在另一个类中：

public class Student {
	public Gender sex;//返回值类型 变成 Gender
	public static void main(String[] args) {
		Student = new Student();
		student.sex  = Gender.MAN;
		System.out.println(student.sex);
		student.sex = Gender.WOMAN;
		System.out.println(student.sex);
	}
}

包装类：
(java.lang 包下面)==》把基本数据类型转换为对象

2.1定义
每个基本类型在java.lang包中都有一个相应的包装类

2.2包装类的作用

1. 提供了一系列实用的方法
2. 集合不允许存放基本数据类型，存放数字时，要用包装类型
3. 基本数据类型 – --> 包装类型
   byte Byte
   short Short
   int Integer
   long Long
   float Float
   double Double
   char Character
   boolean Boolean

父类是Object类型
子类是Boolean、Character和Number类型
Byte、Short、Integer、Long、Float和Double都属于Number的子类

说明：
int不是对象类，Integer才是，
int也不是类，是基本数据类型，即没有路径，没有包
Integer (ctrl) 有包 java.lang 包下。

注意点：
包装类（对象类型）的默认值是null，
基本数据类型的默认值是对应类型的默认值，如int 是 0。

2.3构造方法1（基本数据类型 – --> 包装类 ）
相当于加了一件衣服，本质上还是基本数据类型，只不过变成对象类型了。

int a = 1;
Integer b = new Integer(a);
//如果出现了黄线，就说明这个变量只是定义没有使用
System.out.println(b); 

自动生成相应对象接收返回值的快捷键： alt shift l 和 ctrl + 1

2.4构造方法2（转换为字符串类型的注意点）
场景1：两个字符串进行“+”操作 — 》拼接操作

String a = "123";
System.out.println(a+"1");//1231

场景2.1：一个字符串和一个基本数据类型进行“+”操作 — 》拼接操作
**注意：**int自动转成string

String a = "123";
System.out.println(a+1);//1231

场景2.2：

int a = 123;
String b = a +""; //123

场景3：两个数值类型进行“+”—》算术操作

System.out.println(123 + 1);//124

场景4：将字符串包装后和数值进行 “+”操作 — 》算术操作

String b ="123";
Integer b_new = new Integer(b); // b 是变量
//等价于 Integer b_new = new Integer("123");
//将字符串转换成包装类
System.out.println(b_new + 1);//124

注意：
（一）

String b5 ="abc";
Integer b_new = new Integer(b5);

//除了数字的字符串 其他如 abcd 不能放入包装类中，不然会报错
//java.lang.NumberFormatException //数值转换异常

（二）

String b1 = "123";
Integer b2 = b1;// 错的 

//string引用类型 不能直接赋值给 基本数据类型
//不能相互转换，不管是不是包装类

特例
1.除Character类外，其他包装类可将一个字符串作为参数构造它们的实例

Integer j = new Integer("123"); System.out.println(j+1);
//或
int i = 3;System.out.println(“123”+i);
//Character cha = new Character("sdf");编译 报错

2.Boolean中除了"true"(不区分大小写)之外的其他字符串,结果都是false

Boolean i = new Boolean("adasfgfgdsgh");
System.out.println(i);//false

2.5常用方法：
（1）xxValue()包装类转换成基本类型

Integer a = new Integer(123);
int a_new = a.intValue();

（2）toString()基本类型转换成字符串类型
第一种 更推荐（拼接字符串） --》 是企业推荐（重点）

int a = 12;
String b =a + "";

第二种 不常用

int a =12;
String b = Integer.toString(a);
//或 
String a = Integer.toString(25);
(String sex = Character.toString(‘男’);)

（3）paresXXX()字符串类型—》基本类型（Character除外）

String a ="123";
//将String类型转换成int类型
int num = Integer.parseInt(a);

特例：

//String d = "男";
//Character.parseXXX(d);
//没有将String类型转换成char类型的方法

（4）valueOf()
valueOf第一种实现：基本数据类型 — > 包装类型(没有特例)

int a = 123;
Integer a_new = Integer.valueOf(a);

char c = '男';
Character c_new = Character.valueOf(c);

valueOf()第二种实现：字符串类型 —> 包装类型 （特例：Character）

String b = "123.0"; Double b_new = Double.valueOf(b);

特例：

//String d = "男";
//Character.valueOf(d);
//报错，因为Character没有valueOf()方法

2.6装箱和拆箱
(1)定义
**装箱：**基本数据类型可以自动转换为包装类型（包装类的对象）
—> JDK1.5之后的特性 系统自动转换

Integer intObject = 5;

拆箱： （包装类对象）包装类可以自动转换为基本数据类型

int b = intObject;

(2)附注
包装类并不是用来取代基本数据类型的
（在基本数据类型需要用对象表示时使用）

2.7 String类(重点)
（1）使用

String a = "hello world";

String a = new String("hello world");

1.在常量池创建一个空间存放“hello world”字符串
2.在堆里面创建一个空间存放“hello world”对象
3.变量指向---- 》 堆里的对象空间

为什么方法区里也有一个字符串！
String是一个特殊的类（final修饰），不能被改变，
所以当以后创建相同的字符串可以指向字符串常量池的同一个
（不算new），这样就可以节省很多空间。

基本数据类型比较内容只能使用“==”

int a =3;
int b =3;
System.out.println(a == b);//true

equals （）是string里的 （独有的） 但其他也会有只不过没有重写。

字符串类型比较内容可以使用==，或者使用equals()

String c ="123";
String d ="123";
System.out.println(c.equals(d));//true

== 和equals()的区别 ---- ->极其重要！！！！

字符串比较的方法
equals() 比较两个字符串的内容是否相同
== 比较字符串内存地址是否相等，比较两个字符串是否为同一对象

场景1：

String a ="hello";
String b ="hello";
System.out.println(a.equals(b));//内容相同 true
System.out.println(a == b);//地址相同  true

或

String a ="hello";
String b ="hello2";
System.out.println(a.equals(b));//false
System.out.println(a == b);//false

注意点：
指向加引号 不叫指向方法区 一般是指向堆 字符串常量没有重复的

题外话：
是不是只要是没有new , 内容相同的话,地址一定相同?
错的 正向推 不能反向推

场景2：

String c = "hello";
String d =new String("hello"); 	System.out.println(c.equals(d));//true
System.out.println(c == d);//false

场景3：

String e = "hello";
String f = new String("Hello");
System.out.println(e.equals(f));//false
System.out.println(e == f);//false

场景4：

String g = new String("hello");
String h = new String("hello");
System.out.println(g.equals(h));//true
System.out.println(g == h);//false

场景5：
创建了4个对象

String i = new String("hello");	
String j = new String("Hello");
System.out.println(i.equals(j));//false
System.out.println(i == j);//false

(2)常用方法
A.length()

String a =”helloworld”;
System.out.println(a.length());

B.==和equals()的区别（重点）（如上）

C.equalslgnoreCase()
equalsIgnoreCase() 方法
用于将字符串与指定的对象比较，不考虑大小写

String a = "tom";
String b = "TOM";
System.out.println(a.equalsIgnoreCase(b));//true

D.toLowerCase()
toLowerCase()将字符串转换为小写

String c = "tom";
String d = "TOM".toLowerCase();
System.out.println(c.equals(d));//true

E.toUpperCase()
toUpperCase() 将 字符串转换成大写

String e = "tom".toUpperCase();
String f = "TOM";
System.out.println(e.equals(f));//true

F.concat()
concat() 将两个字符串拼接

String g = "abc";
String h = "d";
System.out.println(g.concat(h));//abcd
	

	int aa =3;
	int bb=4;
	String aa_new = aa + "" +bb;
	//顺序 从左往右 aa + bb+ "" ; 结果为 7
	//等价于String
	//String aa_new
 //= Integer.toString(aa).concat(Integer.toString(bb));  
		System.out.println(aa_new);//34

G.trim()
trim()把字符串两边的空格去除

String j = "  hello world   ";
System.out.println(j.trim());//hello world

H.indexOf()
indexOf()查询索引

		String x = "hello yes world yes yes";
		int index = x.indexOf("o");
		System.out.println(index);//4
		
		int index2 = x.indexOf("girl");
		System.out.println(index2);//当不存在 则为-1
		
		int index3 = x.indexOf("yes");
		System.out.println(index3);//6
		
		int index4 = x.lastIndexOf("yes");
		System.out.println(index4);//20

I.substring()
substring()截取字符串

String y ="hello yes world yes";
System.out.println(y.substring(4));//o yes world yes
System.out.println(y.substring(0,4));//左闭右开区间 hell

J.split()
split()分割字符串

		String song = "长庭外，古道边，芳草碧连天，爱你";
		String[] songsArry = song.split("，");
		for (String ss : songsArry) {
			System.out.println(ss);
		}
		/*
		 * 长庭外
		古道边
		芳草碧连天
		爱你
		 */

2.8StringBuffer
(1)StringBuffer产生的原因（对字符串频繁修改，StringBuffer效率高）
场景1： String字符串的拼接

		String s = "hello";
		s = s.concat("world");// 效率极低
		System.out.println(s);// helloworld
//或
		String s = "hello";
		s.concat("world");
		System.out.println(s);// hello

用String不能直接拼接，需要先赋值再拼接太麻烦，
所以就有了StringBuffer。

场景2： StringBuffer字符串的拼接

StringBuffer b = new StringBuffer("hello");
b.append("world");
System.out.println(b); // helloworld

场景3： StringBuffer转换成String（利用toString（）方法）

StringBuffer b1 = new StringBuffer("hello");
String s2 = b1.toString();

场景4： String转换成StringBuffer（利用实例化StringBuffer对象）

String s3 = "hello";
StringBuffer b2 = new StringBuffer(s3);
b2.append("world");
System.out.println(b2); // helloworld

(2)使用

(3)常用方法

StringBuffer b3 = new StringBuffer("hello");
		System.out.println(b3.length());//5
//x.length()是计算x的长度
		b3.insert(2, ",");
		System.out.println("---------insert之后--------" + b3);
//---------insert之后--------he,llo
x.insert(x, "y");//是插入在某一位置。

2.8日期类型
import java.util.Date;
目前学习是java.util包下，以后是java.sql包下
（1）获取当前日期
1.实例化Date对象

Date date = new Date();//ctrl  shift  o

2.输出系统当前的时间

System.out.println(date);

结果类似于：（实时的）
Sat Oct 30 15:30:13 CST 2021

（2）字符串类型转成Date类型

String s = "2021-09-02 07:00:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//（要导包import java.text.SimpleDateFormat;）
Date date1 = sdf.parse(s);
// sdf.parse(s);会抛转换异常 所以要自己加解决的方法比如：
//throws ParseException  它是编译时异常 必须要抛,必须导包
System.out.println(date1);

结果：
Thu Sep 02 07:00:00 CST 2021

（3）Date类型转成字符串类型
//实例化SimpleDateFormat对象，定义日期字符串的输出规则

SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr = sdf1.format(date);
System.out.println(dateStr);

结果：
2021-10-30 15:30:13

注意点：：
yyyy-MM-dd HH:mm:ss 大写不能改小写 不然以后的数据库 前端会出错
变量名要有意义 最好不要 什么 aaabbbccc

待解决的问题：定义char字符型 时加单引号与不加单引号的区别
除Character类外，其他包装类可将一个字符串作为参数构造它们的实例 为什么？

----2021.08.24&08.25&08.26