01JavaSE入门基础总结

PV:

一、String介绍(引用类型)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
1.java.lang.String字符串.
	用""括住的时字符串,都可以看做是实现此类的实例
	类String中也有许多简单方法

2.特点
	1).字符串不变:字符串的值在创建后不能被更改
	2).因为String对象不可改变.所有他们可以被共享
	3).(底层是这么实现的)对String s1 赋值 "abc" 等效于char[] data = ['a','b','c']

3.构造举例(面试可能会问，)

// 无参构造
String str = new String();

// 通过字符数组构造
char chars[] = {'a','b','c'};
String str2 = new String(chars);

// 通过字节数组构造
byte b[] = {97,98,99};
String str3 = new String(b);

4.字符串的比较（面试的时候会问，结合String进行理解）
	1.		== 		比较
		1.对基本类型 这个东西 可以 比较基本类型 四类八种 （比较的是值是否相等）
		2.对引用类型进行比较时， 则比较地址值
		
	2.equals(String str)  
		内容相同 ，返回true
		
5.String 方法
（1）获取
equalsIgnoreCase(String str)	忽略大小写比较内容

int	length()	返回字符串长度

String	concat 		将指定的字符串连接到该字符串的末尾

char	charAt(int index)	返回指定索引处的char值

int indexOf(String str) 	返回指定字符串第一次出现该字符串的位置(索引)	找到了就是对应的首次出现的索引，找不到就返回-1

String substring (int beginIndex) 返回一个字符串，从beginIndex开始截取字符串到最后

String substring (int beginIndex, int endIndex) 返回一个字符串，从beginIndex开始截取字符串
到endIndex截取字符串。 含beg 不含 end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
（2）转换
1.String replace()
ex:
	String str = "abbccd"
	String newstr = str.replace('b','*')
	System.out.println(newstr)
		
		a**ccd
	此处将含有b的全部替换成*了
	
	String newstr = str.replace("bb","*")
	
		运行结果为a*ccd
2.
char [] chars = toCharArray()转成字符数组	
3.
	byte[] getByte();使用平台默认的字符集将该String编码新的字节数组.
4. String[] split(String regex)   ""\\."表示.转义一下
	以 regex对字符串进行分割

二、StringBuffer

1
2
3
4
5
6
7
8
9
10
1.类介绍 
	①线程安全的可变字符串序列，一个类似于String的字符串缓冲区，但是不能修改（就是不能通过加号+连接，String就可以）
	②StringBuffer和String类的区别
		String是一个可改变的字符序列
		StringBuffer是一个可变的字符序列
2.构造方法
	StringBuffer()	构造一个没有字符的字符串缓冲区，初始容量为16个字符
	StringBuffer(int capacity)	构造一个没有字符的字符串缓冲区和指定初始容量
	StringBuffer(CharSequence seq)	构造一个字符串缓冲区,其中包含与指定的 CharSequence相同的字符。
	StringBuffer(String str)	构造一个初始化为指定字符串内容的字符串缓冲区。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
	notes:
		从jdk5开始,为该类补充了一个单个线程使用的等价类,即StringBuilder类,通常优先使用StringBuilder类,因为他支持所有相同操作,但是由于它不执行同步,所有速度更快
3.增删,替换翻转,截取()

	StringBuffer sb = new StringBuffer("abcd");
	①添加
	sb.append("str12");			//在末尾添加一个字符串
	sb.insert(3,"hhh");			//在指定位置添加指定字符串
	②删除
	sb.deleteCharAt(3);			//删除指定1位置的字符 并返回本身
	sb.delete(1,3);     //左闭右开
	③清空缓冲区
	sb.delete(0,sb.length());
	
	④替换
	sb.replace(0,3,"bai")	// 包含头不包含尾
	⑤翻转
	sb.reverse();
	⑥截取
	sb.substring(int start)		//从指定位置截取到末尾
	sb.substring(int start,int end)		//从指定位置开始到结束位置，包括开始位置，不包括结束位置
	// 截取 返回值不再是StringBuffer而是String

4.StringBuffer  --> String
	String --》 StringBuffer
		a.通过构造方法
			StringBuffer stringBuffer = new StringBuffer("woai");
			System.out.println(stringBuffer);       // 通过构造方法完成转换成String
		b.通过append()方法
			StringBuffer stringBuffer = new StringBuffer();
			stringBuffer.append("woai");
			System.out.println(stringBuffer);       // 通过append()方法完成转换成String
	
	StringBuffer --》 String
		StringBuffer sb = new StringBuffer("woai1");
		a.通过构造方法
			String s = new String(sb);      // 通过构造方法
			System.out.println(s);
		b.通过toString()方法
			String string = sb.toString();      //通过toString()方法
			System.out.println("string = " + string);
		c.通过subString(0,length);
		    String substring = sb.substring(0, sb.length());
			System.out.println(substring);
	
5.数组 --> 字符串
	举例：
		int [] arr = {1,2,3,};
	输出结果:
		"[1,2,3]"
	用StringBuff的功能实现：
		int[] arr = {1, 2, 3};
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
            stringBuffer.append(arr[i]).append("]");		//	使用这样的添加方式会减少垃圾的存在
			}else {
            stringBuffer.append(arr[i]).append(",");
			}
		}
		System.out.println(stringBuffer);

6.字符串翻转
	通过StringBuffer进行翻转
	
7.StringBuffer和StringBuilder区别
	StringBuffer是jdk1.0版本的，是线程安全的，效率低的 		(对于用户访问量大的bat 保证其稳定性，对于金融要求，保证其稳定，其他都不存在)
	StringBuilder是jdk1.5版本的，是线程不安全的，效率高的
	
	String和StringBuffer，StringBuilder的区别
		String是一个不可变的字符序列
		StringBuffer，StringBuilder是可变的字符序列

8.String和StringBuffer作为参数传递
	基本数据类型的值传递，不改变其值
	引用数据类型的值传递，改变其值		//	因为传递的是内存地址，
	
	String s = "heihei";
    System.out.println(s);
    change(s);
    System.out.println(s);	//	heihei
1
System.out.println("------------------");
1
2
3
4
StringBuffer sb = new StringBuffer();
sb.append("hhhhhh");
change(sb);
System.out.println("sb = " + sb);	// heiheihhhhhh
1
2
3
4
5
6
7
8
9
10
9.数组-冒泡,选择,二分排序
	(1)冒泡
		// 数据元素：{24,69,80,57,13}
			相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
	(2)选择
	(3)二分排序
10.Arrays类
11.Interger类
12.String --> int
13.Interger面试题

​
三、StringBuffer的构造方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
* public StringBuffer():无参构造方法
* public StringBuffer(int capacity)	指定容量的字符串缓冲区对象
* public StringBuffer(String str) 指定字符串内容的字符串缓冲区对象

StringBuffer sb = new StringBuffer()
sb.append("")
sb.insert(int offset , String str)// 
// 在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串本身
// 在new的时候是在堆内存中创建了一个对象，底层是一个长度为16的字符数组，当调用添加方法时，不会再重新创建对象，在不断向原缓冲区添加zifu
sb.deleteCharAt(4) // 根据索引删除索引位置上对应的字符
sb.detel(0,2)		// 删除的时候包含头不包含尾
sb.detel(0,sb.length()) 	// 情况缓冲区
sb.replace(0,3,"bai")		// 替换  替换指定区域的字符
sb.reverse()				// 翻转
sb.substring()				// 截取
sb.reverse()				// 翻转

String   --> StringBuffer

	//通过构造方法
	//和 append 将  字符串 转换为 StringBuffer对象
	StringBuffer sb = new StringBuffer("heima")
	
StringBuffer   --> String

	// 通过构造方法
	// 通过toString()方法
	// 通过subString(0,length)

StringBuffer和StrinBuilder的区别：

四、Arrays

1
java.util.Arrays(操作数组的各种方法,如排序和搜索)
1
2
1.sort 排序 直接打印 无返回值
2.

五、Math

1
2
3
4
java.lang.Math 类包含用于基本数学运算方法,如初等指数,对数,平方根和三角函数
其所有方法为静态方法，并且不会创建对象，调用起来非常简单。

1.abs
1
2
3
4
5
Math.sqrt()//计算平方根
Math.cbrt()//计算立方根
Math.pow(a, b)//计算a的b次方
Math.max( , );//计算最大值
Math.min( , );//计算最小值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
System.out.println(Math.sqrt(16));   //4.0 
System.out.println(Math.cbrt(8));    //2.0
System.out.println(Math.pow(3,2));     //9.0
System.out.println(Math.max(2.3,4.5));//4.5
System.out.println(Math.min(2.3,4.5));//2.3

/** 
 * abs求绝对值 
 */  
System.out.println(Math.abs(-10.4));    //10.4  
System.out.println(Math.abs(10.1));     //10.1  

/** 
 * ceil天花板的意思，就是返回大的值
 */  
System.out.println(Math.ceil(-10.1));   //-10.0  
System.out.println(Math.ceil(10.7));    //11.0  
System.out.println(Math.ceil(-0.7));    //-0.0  
System.out.println(Math.ceil(0.0));     //0.0  
System.out.println(Math.ceil(-0.0));    //-0.0  
System.out.println(Math.ceil(-1.7));    //-1.0

/** 
 * floor地板的意思，就是返回小的值 
 */  
System.out.println(Math.floor(-10.1));  //-11.0  
System.out.println(Math.floor(10.7));   //10.0  
System.out.println(Math.floor(-0.7));   //-1.0  
System.out.println(Math.floor(0.0));    //0.0  
System.out.println(Math.floor(-0.0));   //-0.0  

/** 
 * random 取得一个大于或者等于0.0小于不等于1.0的随机数 
 */  
System.out.println(Math.random());  //小于1大于0的double类型的数
System.out.println(Math.random()*2);//大于0小于1的double类型的数
System.out.println(Math.random()*2+1);//大于1小于2的double类型的数

/** 
 * rint 四舍五入，返回double值 
 * 注意.5的时候会取偶数    异常的尴尬=。=
 */  
System.out.println(Math.rint(10.1));    //10.0  
System.out.println(Math.rint(10.7));    //11.0  
System.out.println(Math.rint(11.5));    //12.0  
System.out.println(Math.rint(10.5));    //10.0  
System.out.println(Math.rint(10.51));   //11.0  
System.out.println(Math.rint(-10.5));   //-10.0  
System.out.println(Math.rint(-11.5));   //-12.0  
System.out.println(Math.rint(-10.51));  //-11.0  
System.out.println(Math.rint(-10.6));   //-11.0  
System.out.println(Math.rint(-10.2));   //-10.0  

/** 
 * round 四舍五入，float时返回int值，double时返回long值 
 */  
System.out.println(Math.round(10.1));   //10  
System.out.println(Math.round(10.7));   //11  
System.out.println(Math.round(10.5));   //11  
System.out.println(Math.round(10.51));  //11  
System.out.println(Math.round(-10.5));  //-10  
System.out.println(Math.round(-10.51)); //-11  
System.out.println(Math.round(-10.6));  //-11  
System.out.println(Math.round(-10.2));  //-10

六、static(在方法区有一块固定的存储区域,由于优先于对象存在,所以可以被所有对象共享)
​ 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
在定义方法的时候你写main方法的类加static,
写普通类的写方法的时候就不要加static

1.static可以用来修饰成员变量和成员方法，
被修饰的成员属于类，而不是单单属于某个对象，
也就是说，既然属于类，就可以不靠创建对象来调用了

进一步介绍：
	修饰成员变量
	当static修饰成员变量时，该变量称为类变量，该类的每个对象都共享同一个类变量的值，任何对象都可以更改
	该变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作
		
		类名.类变量
		类名.静态方法名(参数);
1
修饰成员方法 (静态方法可以访问静态变量,不能访问普通的变量)
1
2
3
4
5
类名.方法() 推荐
对象名.方法名() 麻烦

特点
静态方法只能访问静态内容(成员变量,静态成员方法)

​
​ 

1
2
3
4
notes:
	静态方法 可以直接访问 静态变量和 静态方法.
	静态方法 不能直接访问 普通成员变量 或 成员方法,反之成员方法可以直接访问静态变量或静态方法
	静态方法 不能使用this关键字

​
七、静态代码块(想在main方法之前执行,可以给静态成员变量赋值)

1
2
3
4
5
6
7
8
9
10
静态代码块：定义成员位置，使用static修饰代码块()
位置:类方法外
执行:随着类的加载而执行且执行一次,优先于main方法构造和构造方法执行

格式:
	public class ClassName{
		static{
			// 
		}
	}

​

JAVA中分为基本数据类型和引用数据类型区别
一、基本数据类型：

byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0

short：短整型，在内存中占16位，即2个字节，取值范围-32768~32717，默认值0

char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空

int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0

long：长整型，在内存中占64位，即8个字节-2^63~2^63-1，默认值0L

float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字（与double的区别在于float类型有效小数点只有6~7位），默认值0

double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0

boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false

二、引用数据类型：

类、接口类型、数组类型、枚举类型、注解类型。

区别：

基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上。

引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。

例如，有一个类Person,有属性name,age,带有参的构造方法，

Person p = new Person(“zhangsan”,20);

在内存中的具体创建过程是：

1.首先在栈内存中位其p分配一块空间;

2.在堆内存中为Person对象分配一块空间，并为其三个属性设初值””，0；

3.根据类Person中对属性的定义，为该对象的两个属性进行赋值操作；

4.调用构造方法，为两个属性赋值为”Tom”,20；（注意这个时候p与Person对象之间还没有建立联系）；

5.将Person对象在堆内存中的地址，赋值给栈中的p;通过引用（句柄）p可以找到堆中对象的具体信息。

相关知识：

静态区： 保存自动全局变量和 static 变量（包括 static 全局和局部变量）。静态区的内容在总个程序的生命周期内都存在，由编译器在编译的时候分配。

堆区： 一般由程序员分配释放，由 malloc 系列函数或 new 操作符分配的内存，其生命周期由 free 或 delete 决定。在没有释放之前一直存在，直到程序结束，由OS释放。其特点是使用灵活，空间比较大，但容易出错

栈区： 由编译器自动分配释放，保存局部变量，栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也会自动被销毁，其特点是效率高，但空间大小有限

文字常量区： 常量字符串就是放在这里的。 程序结束后由系统释放。

Powered by Hexo and Hexo-theme-hiker

Copyright © 2016 - 2018 Francis的个人博客 All Rights Reserved.

UV : | PV :