202106小白训练营day03-java数据结构

Posted 2021-06-30 长安紫薯

变量，java程序把数据保存到变量中，就可以调用变量从而获得它数据，进行计算。
java提供哪些具体的变量类型支持：
1）变量类型？ int a = 10;
2）提供两种变量类型分类：a. 值，b.引用
值类型：8种基本类型
引用类型：非基本类型就是引用类型（String s = “abc”; 字符串，数组，对象Object ）。

8种基本类型

小的分类：3个分类，整数类型、小数类型（浮点数）、其他（字符、布尔）
1）byte 字节，8bit 比特，1字节，Byte
2）short 短整型，2字节，Short
3）int 整型，4字节，Integer*
4）long 长整型，8字节，Long

5）float 单精度浮点数，4字节，Float
6）double 双精度浮点数，8字节，Double

7）char 字符型，2字节，Character*
2~4个字节 ASCII，ISO-8859-1，GBK，UTF-8，UTF-16，UTF-32
8）boolean 布尔型，true 1/false 0，1字节，Boolean

现在要存100和200，使用什么整数类型？

规定：使用变量时，尽量使用合适的数据类型来存储，尽量所占用空间小，性能高

package cn.tedu.datatype;

import org.junit.Test;

//数据类型
public class DataType {
	//实现存储整数100
	@Test
	public void save100() {
		byte b = 100;
		System.out.println(b);
		
		short s = 100;
		System.out.println(s);
	}
	
	//实现存储整数200
	@Test
	public void save200() {
		/*
		 * Type mismatch: cannot convert from int to byte
		 * 类型不匹配，不能由int整型转换为byte字节类型
		 * java默认声明一个整数，这个整数默认int类型
		 * 可以强硬转换，但是精度损失风险
		 * (byte)强制类型转换
		 */
		byte b = (byte)200;	//它有一个支持数值范围
		System.out.println(b);
		
		short s = 200;		//自动类型转换
		System.out.println(s);
	}
}

借助包装类型获取数据类型的取值范围

package cn.tedu.datatype;

import org.junit.Test;

/*
 * 打印出所有基本数据类型取值范围
 * 基本类型自身是不支持获取类型的范围
 * java推出包装类型，借助包装类型来获取它取值范围
 * 每个基本类型对应一个包装类型
 */
public class ValueScope {
	@Test
	public void scope() {
		//-128~127，1byte=8bit=2^8=256 一半存负数，一半存正数
		System.out.println("Byte字节取值范围："
				+ Byte.MIN_VALUE + "~" + Byte.MAX_VALUE);
		
		//-32768~32767，2byte=2^16=65536
		System.out.println("Short短整型取值范围："
				+ Short.MIN_VALUE + "~" + Short.MAX_VALUE);
		
		//正负21亿
		System.out.println("Integer整型取值范围："
				+ Integer.MIN_VALUE + "~" + Integer.MAX_VALUE);
		
		System.out.println("Long长整型取值范围："
				+ Long.MIN_VALUE + "~" + Long.MAX_VALUE);
		
		//1.4E-45 科学计数法，E后面代表有多少个零
		System.out.println("Float单精度浮点数取值范围："
				+ Float.MIN_VALUE + "~" + Float.MAX_VALUE);
		
		System.out.println("Double双精度浮点数取值范围："
				+Double.MIN_VALUE + "~" + Double.MAX_VALUE);
	}
}

ASCII字符集，char和String的区别

package cn.tedu.datatype;

import org.junit.Test;

/*
 * 打印出所有基本数据类型取值范围
 * 基本类型自身是不支持获取类型的范围
 * java推出包装类型，借助包装类型来获取它取值范围
 * 每个基本类型对应一个包装类型
 */
public class ValueScope {
	@Test
	public void scope() {
		// -128~127，1byte=8bit=2^8=256 一半存负数，一半存正数
		System.out.println("Byte字节取值范围：" + Byte.MIN_VALUE + "~" + Byte.MAX_VALUE);

		// -32768~32767，2byte=2^16=65536
		System.out.println("Short短整型取值范围：" + Short.MIN_VALUE + "~" + Short.MAX_VALUE);

		// 正负21亿
		System.out.println("Integer整型取值范围：" + Integer.MIN_VALUE + "~" + Integer.MAX_VALUE);

		System.out.println("Long长整型取值范围：" + Long.MIN_VALUE + "~" + Long.MAX_VALUE);

		// 1.4E-45 科学计数法，E后面代表有多少个零
		System.out.println("Float单精度浮点数取值范围：" + Float.MIN_VALUE + "~" + Float.MAX_VALUE);

		System.out.println("Double双精度浮点数取值范围：" + Double.MIN_VALUE + "~" + Double.MAX_VALUE);

		// 布尔值是没有取值范围，就两个值
		System.out.println(Boolean.TRUE);
		System.out.println(Boolean.FALSE);
	}
	
	//字符char/Character和字符串String的区别？
	@Test
	public void Char2String() {
		// 'a'和"a"，单撇Java中是给字符使用，双撇Java中是给字符串使用
		//Type mismatch: cannot convert from String to char
		//char c = "a";
		
		//char c = 'a';		//字符和整数可以互换
		char c = 50;		//97=a，48=0，ASCII（定义、为什么需要它）
		//美国标准信息交换码，人类和电脑进行信息交换
		//键盘上输入字母或者数字，电脑接收后先把每个字母转换整数
		//整数可以转换2进制，由2进制，转换整数，转换对应字母，然后显示屏展示
		//意义，编程语言和计算机进行数据交换，沟通
		System.out.println(c);  //a
		
		//ISO-8859-1 它完全包含ASCII，增加西欧字符支持
		//GB2312，GBK，支持汉字
		//UTF8,16,32，32=4byte囊括了全球所有的字符，u16不同的长度a占2个字节，生僻字4个字节，u8 1~4字节
		//上面的叫编码规则，还有一个统称unicode
		
		//和字符串有什么区别？
		char c1 = 'a';		//字符，字符类型只能存放一个
		char c2 = 'b';
		char c3 = 'c';
		String s = "abc";		//字符串，一个一个字符，写多个字符
		System.out.println(""+c1+c2+c3);
		System.out.println(s);
		
		//[]括号括起来内容数组
		char[] d = {'a','b','c'};  //一组值，String字符串的本质
		System.out.println(d);
		
		//打印字符范围：ASCII第一值和最后一个值，不可见字符
		System.out.println("=="+Character.MIN_VALUE+"==");
		System.out.println("=="+Character.MAX_VALUE+"==");
	}
	
}

java面向对象开发语言，提倡面向对象，但是它有一个部分也是唯一一个部分不属于面向对象概念。
8个基本类型。因为面向对象结构比较复杂，但是它带来很多好处，而这些好处会造成占用一定内存空间，性能比起基本类型变量性能稍低。
int a = 10;
int[] arr = {1,2,3,4,5};
byte b1 = 100; 占用空间小，执行性能高
Byte b2 = 100; 占用空间大，执行性能低，好处，额外方法

基本类型保存是值，而数组类型它属于对象保存是引用
int i = 10; 打印i看是什么值？
int[] arr = {1,2,3,4,5}; 打印arr看是什么？

数组声明、访问、打印、排序

package cn.tedu.datatype;

import java.util.Arrays;

import org.junit.Test;

//展示值和引用区别，通过基本类型和数组（引用类型）案例
public class Array {
	@Test
	public void arr() {
		// 值类型，基本类型打印展示具体值
		int i = 10;
		System.out.println("值类型：" + i);

		// 引用类型，[I@780cb77 打印数组所在内存地址起始位置
		int[] arr = { 10 }; // 数组只有一个元素
		System.out.println("引用类型：" + arr);

		// [Ljava.lang.String;@691a7f8f 打印字符串内存空间首地址
		String[] s = { "1", "2" };
		System.out.println(s);
	}

	@Test // 数组声明（定义）、访问、打印、排序
	public void arr2() {
		// 定义，int代表数组元素的类型，数组是一组值，特点：每个元素类型一致
		// 新建对象，只要是new关键字创建对象，它就是引用类型
		int[] a1 = new int[3]; // 数组的个数，数组长度
		// 基本类型的默认值整数0，小数0.0，字符NUL，布尔false
		// int[] a2 = {1,2,3}; //两个动作，定义，初始化

		// 设置数组元素值，第一次初始化
		a1[0] = 1;
		a1[1] = 22;
		a1[2] = 3;
		
		//java.lang.ArrayIndexOutOfBoundsException: 
		//Index 3 out of bounds for length 3 数组越界
		//a1[3] = 10; //逻辑错误，隐性错误，运行时

		// 访问，java的下标是从0开始
		System.out.println("数组的第一个元素：" + a1[0]);
		System.out.println("数组的最后一个元素：" + a1[2]);

		// 打印，打印数组的每个元素
		System.out.println(a1);
		// 第一方法：挨个打印每个元素
		System.out.print(a1[0]);
		System.out.print(a1[1]);
		System.out.print(a1[2]);

		System.out.println();

		// 第二方法：引入工具类api，Arrays提供很多方法toString()
		// 非java.lang.*下，需要导包 java.util.Arrays工具类
		System.out.println(Arrays.toString(a1));

		// 数组保留之前的值，排序是新的数组
		int[] b = a1; // 记录旧的数组
		// 把a1数组的长度创建新的数组，然后把对应元素值存入
		System.out.println("旧的数组：" + Arrays.toString(b));

		// 排序，自身没有提供方法，工具类Arrays提供sort，升序
		Arrays.sort(a1); // 排序后数组的内容会被改变
		System.out.println("新的数组：" + Arrays.toString(a1));

	}
}

为什么需要对象Object？

1）基本类型，值类型，简单变量，局限性它只能表达一个类型的一个值。
2）数组类型，引用类型，复杂一点点，数组多个（0~n）, 局限它只能表达一个类型多个值。
突破上面限制，多个类型，多个值，java提供万能解决方案：对象

习惯：对象属性（字段），它数据类型都使用包装类型
人：Person
1）name 姓名，字符串类型， String
2）sex 性别，布尔型，Boolean
3）age 年龄，整数型，Integer
4）address 地址，字符串类型，String
5）scores 高考成绩，小数数组，Float[]

Person.java

package cn.tedu.pojo;

//定义：一个Person对象
public class Person {
	//写在方法体内的变量叫局部变量，写在类中的变量叫成员变量
	String name; //姓名
	Boolean sex; //性别，true 1男 false 0女
	Integer age; //年龄
	String address; //地址
	Float[] scores;	//高考成绩
}

TestPerson.java

package cn.tedu.pojo;

import java.util.Arrays;

import org.junit.Test;

//测试
public class TestPerson {
	@Test
	public void person() {
		//1. 创建对象（类必须先创建实例instance才能使用）
		//类名大驼峰，对象（实例）名小驼峰
		Person person = new Person();
		
		//2. 设置属性值，怎么获取对象属性值？.操作符
		person.name = "邦德";  	//对象属性的赋值
		person.sex = true;		//男
		person.age = 70;
		person.address = "英国伦敦";
		
		//声明一个小数，java默认double来处理，增加后缀 f/F Float
		//Float[] scores = {120.0F, 110.0F, 100.0F };
		person.scores = new Float[]{120.0F, 110.0F, 100.0F };
		
		//3. 打印对象属性值
		System.out.println("姓名：" + person.name);
		System.out.println("性别：" + person.sex);
		System.out.println("年龄：" + person.age);
		System.out.println("地址：" + person.address);
		System.out.println("成绩：" + Arrays.toString(person.scores));
		
		//4. 打印对象
		System.out.println(person);
	}
}

Student.java

package cn.tedu.pojo;

//学生类（张三，李四）类只是一个，对象可以n个
public class Student {
	String name;	//姓名
	Integer age;	//年龄
	String school;	//学校
	
	//覆盖父类Object.toString()
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", school=" + school + "]";
	}
	
}

TestStudent.java

package cn.tedu.pojo;

import org.junit.Test;

//学员测试，创建张三和李四
public class TestStudent {
	@Test
	public void student() {
		// 创建张三，设置属性，打印
		Student s1 = new Student();
		s1.name = "张三";
		s1.age = 30;
		s1.school = "北京";
		System.out.println(s1);

		// 创建李四，设置属性，打印
		Student s2 = new Student();
		s2.name = "李四";
		s2.age = 40;
		s2.school = "西安";
		System.out.println(s2);
	}
}

小结

1）数据结构
早期编程注重使用变量类型要占内存尽量小，执行快。
现在网络，硬件（内存，磁盘，CPU）现今程序不是太关注类型，注重程序安全，稳定，架构
2）合理去存储它数据
整数100，使用byte类型，如果整数200，使用short
3）java支持数据结构常见类型
a. 8个基本类型，另类，不属于对象。在方法体内声明局部变量，参数 a,b,x,y，习惯，值类型
b. 数组，引用类型，int[] arr = {1,2,3,4} 存储多个同类型值
c. 对象，第一公民，对象占空间大 Byte.MIN_VALUE，构建对象慢，调用慢，好处额外方法，开发效率高。把生活中内容可以抽象对象，更好写代码和理解。
4）8个基本类型，4整数，2小数，2其它（基本类型声明全小写）
a. byte 字节，8bit 1字节，范围：-128~127，256=2^8
byte i = 10; 自动类型转换，int转byte
byte i = (byte) a; 类型强制转换，风险，精度损失
b. short 短整型，2字节，范围：-32768~32767，65536,=2^16
c. int 整型，4字节，范围：±21亿，默认写一个数字是整数int
d. long 长整型，8字节 l/L
e. float 单精度浮点数，4字节 f/F
f. double 双精度浮点数，8字节，默认写一个小数是double d/D
g. char 2字节，unicode 字符集 1~4字节 编码：ASCII，ISO-8859-1，GB2312，GBK，UTF-8，UTF-16，UTF-32
h. boolean 1字节，非零true，零false
5）包装类型和基本类型什么关系？
包装类型是Java给对应基本类型提供很多额外方法，它可以把基本类型转换对象
基本类型是值，包装类型是引用类型。
Byte、Short、Integer、Long、Float、Double、Character、Boolean
6）基本类型、包装类型、引用类型
包装类型把基本类型封装，变成对象；
基本类型不是引用类型，包装类型是引用类型。
7）数组，它是一组值
8）对象