java小白训练营day03-数据结构：基本类型+包装类型+数组+对象(代码片段)

程序

程序员（新民工）
旧程序：数据结构+算法，老程序员关注的内容，计算机硬件水平落后（怎么节约内存，怎么加快计算速度，单机）
去大厂，关注基础扎实度，考核java基础

新程序：数据结构+算法（了解）+框架+架构（重点）（浪费一点内存没关系，浪费一点CPU计算机速度没关系）
（分布式，多台机器，100/10000/100000）安全（容错）、高并发（百万级并发、亿级并发）、高可用（不宕机 docker）、海量数据（大数据）
去各个岗位（大中小）关注，基础其次，主要框架和架构
java大数据（CGB）课程主要内容的重点就轻java基础，轻javaWeb（前端），重互联网架构，重大数据架构，高薪！

 数据结构：是计算机存储、组织数据的方式。是一种具有一定逻辑关系，在计算机中应用某种存储结构，并且封装了相应操作的数据元素的集合。它包含三方面的内容，逻辑关系、存储关系以及操作。
 算法：能够解决实际问题，输入的所有可能的合法的输入都能产生预期的正确的结果；能够在有穷的步骤内执行完程序；能够用最简短的语句最高效的完成任务。

数据结构非常丰富

整数、小数、字符、字符串、布尔、数组、集合、对象、树、图

java中把数据类型分类：

1）基本类型：8种基本类型，4个整数、2个小数、2个特殊
2）引用类型：除了基本类型都是引用类型，数组，对象。。。

为什么java中要有基本类型呢？

java是面向对象语言，它提倡万物皆对象。
对象一般都比较复杂的，它有一个创建过程 new Person( name,age,address )；分配很复杂内存空间的，执行速度低。
如果有大量的日常简单的变量来分配内存空间，性能太低了。
int x = 10; 性能高
java 额外允许基本类型的特殊存在！

基本类型

计算机硬件最小单位bit ，比特，二进制，电路（开1、关0）
1 byte = 8 bit = 2^8 = 256
1KB = 1024B = 2^10 byte （文件系统）
1GB = 1024KB（磁盘分区）
1TB = 1024GB（移动硬盘、硬盘）
1PB = 1024TB（大数据入门，双11）
1EB = 1024PB（谷歌、百度历史数据总和）

1）byte 字节，长度：1字节，范围：2^8，256，-128~127
2）short 短整型，长度：2字节，范围：2^16，65536，-32768~32767
3）int 整型，长度：4字节，范围：2^32，42亿，正负21亿。默认数字是整数
4）long 长整型，长度：8字节，范围：2^64

5）float 单精度浮点数，长度：4字节，范围：2^32
6）double 双精度浮点数，长度：8字节，范围：2^64。默认小数是双精度浮点数

7）char 字符型，长度：2字节，（1~3字节 ASCII，ISO-8859-1，GBK，UTF-8，UTF-16，UTF-32）
8）boolean 布尔型，true 1/false 0，长度：1字节

计算机最小单位是 bit 比特，程序的最小单位 byte 字节

需求：有两个整数 100、200使用什么类型存储合适？

习惯，利用最小的存储结构来存储，计算速度越快

package test;

import org.junit.Test;

public class TestPrimitype 
	//需求：有100和200，应该使用什么类型存储？
	@Test
	public void num() 
		//尽量采用最小存储类型
		byte b1 = 100;
		System.out.println(b1);
		
		//Type mismatch: cannot convert from int to byte
		//类型不匹配，不能把int转换成byte类型
		//java规定，默认写一个数值，其类型整数 int
		byte b2 = (byte)200;	//强制类型转换
		System.out.println(b2);
	

需求：有10亿（9个0）和100亿（10个0）区别？

package test;

import org.junit.Test;

public class TestPrimitype 
	//需求：有100和200，应该使用什么类型存储？
	@Test
	public void num() 
		//尽量采用最小存储类型
		byte b1 = 100;
		System.out.println(b1);
		
		//Type mismatch: cannot convert from int to byte
		//类型不匹配，不能把int转换成byte类型
		//java规定，默认写一个数值，其类型整数 int
		byte b2 = (byte)200;	//强制类型转换
		System.out.println(b2);
	
	
	//需求：有10亿（9个0）和100亿（10个0）区别？
	@Test
	public void bill() 
		//The literal 10000000000 of type int is out of 
		int i1 = 1000000000; //范围+-21亿
		System.out.println(i1);
		
		long i2 = 10000000000L; //结尾：l/L代表long
		System.out.println(i2);
	

类型转换

byte b1 =100; //自动类型转换，
byte b2 = (byte)200; //强制类型转换（手动转换，有风险）

黑色箭头java会自动转换，自动向上提升
byte，short，char = int ，它自动转换
int = long
int = float 但是有风险，4字节，4字节（一半整数，一半小数）
long = double 但是有风险，8字节，8字节（一半整数，一半小数）

强制转换有风险，很容易溢出
int x = 200;
byte b2 = (byte)x; //强制类型转换

到底写一个值，它应该使用什么类型呢？

结果要知道，每个类型的取值范围

包装类型

java提供了包装类型，每个基本类型对应一个包装类型
小写是基本类型，大写是引用类型（包装类型都是对象）
1）byte，Byte
2）short，Short
3）int，Integer
4）long，Long
5）float，Float
6）double，Double
7）char，Character
8）boolean，Boolean

package test;

import org.junit.Test;

//包装类型和基本类型有什么区别？
public class TestWrapperType 
	@Test
	public void wrapper() 
		byte b1 = 100;  //基本类型
		Byte b2 = 100; 	//包装类型，对象
		//Byte b2 = new Byte(b1); //1、真正写法
		
		//2、b2是对象，对象会额外提供很多方法，基本类型没有的
		//3、包装类型就把基本类型转换成对象，java中就是万物皆对象
		
		System.out.println(b1);
		System.out.println(b2);
	

取值范围

package test;

import org.junit.Test;

//打印8个基本类型取值范围
public class TestScope 
	@Test
	public void scope() 
		System.out.println("Byte范围："+Byte.MIN_VALUE+"~"+Byte.MAX_VALUE);
		System.out.println("Short范围："+Short.MIN_VALUE+"~"+Short.MAX_VALUE);
		System.out.println("Integer范围："+Integer.MIN_VALUE+"~"+Integer.MAX_VALUE);
		System.out.println("Long范围："+Long.MIN_VALUE+"~"+Long.MAX_VALUE);
		
		System.out.println();
		
		//1.4E-45 科学计数法，后面有45个0
		System.out.println("Float范围："+Float.MIN_VALUE+"~"+Float.MAX_VALUE);
		System.out.println("Double范围："+Double.MIN_VALUE+"~"+Double.MAX_VALUE);
		
		System.out.println();
		
		//字符很奇怪的值，不可见字符，NUL空字符，ASCII
		System.out.println("Character范围："+Character.MIN_VALUE+"~"+Character.MAX_VALUE);
		
		//布尔 true和false
		System.out.println( "Boolean范围："+Boolean.TRUE+"~"+Boolean.FALSE);
	

执行结果
Byte范围：-128~127
Short范围：-32768~32767
Integer范围：-2147483648~2147483647
Long范围：-9223372036854775808~9223372036854775807

Float范围：1.4E-45~3.4028235E38
Double范围：4.9E-324~1.7976931348623157E308

Character范围：

字符

char，Character
char c = ‘a’;
String s = “a”;

package test;

import org.junit.Test;

//字符
public class TestChar
@Test
public void chr()
char c1 = ‘a’; //代表键盘的a字母
System.out.println(c1);

	char c2 = 255;	//ASCII码（128，256），意义，它形成人力语言可以翻译成二进制，计算机就可以识别
	System.out.println(c2);

包装类型意义把基本类型封装（包装）对象

这样就统一java处理方式，java面向对象编程 Object，怎么证明？

package test;

import org.junit.Test;

//证明万物皆对象，8个包装类型也是对象
public class TestObject 
	@Test //在java中所有的类都是Object的子嗣（儿子，孙子。。。）
	public void obj() 
		//getClass()方法的作用，得到类名字
		//super超类，getSuperClass，得到父类（超类）
		
		Byte b = 0;	
		System.out.println("自己：" + b.getClass());
		System.out.println("父亲：" + b.getClass().getSuperclass());
		System.out.println("爷爷：" + b.getClass().getSuperclass().getSuperclass());
		System.out.println();
		
		Double d = 0.0D;
		System.out.println("父亲：" + d.getClass().getSuperclass());
		System.out.println("爷爷：" + d.getClass().getSuperclass().getSuperclass());
		System.out.println();
		
		Character c = '0';
		System.out.println("父亲：" + c.getClass().getSuperclass());
		System.out.println("爷爷：" + c.getClass().getSuperclass().getSuperclass());
		
		Boolean bn = true;
		System.out.println("父类：" + bn.getClass().getSuperclass());
		System.out.println("爷爷：" + bn.getClass().getSuperclass().getSuperclass());
	

字符集

1）ASCII 码 128
2）ISO-8859-1 在ASCII上增加了西欧的编码 256，英文网页html
3）GB2312 简体，BIG5 台湾繁体，GBK 65536 英文+中文，中文网站htmll
4）unicode 全球 ：UTF-16（2字节）、UTF-32（4字节）、UTF-8 压缩（英文1字节，3字节）

数组

基本类型也好，包装类型也好，它们有个缺点，只能存储一个类型的一个值。
想存储一个类型的多个值，java为我们提供数组。

定义（声明）、初始化、访问（调用）

数组的定义

两种形式：
1）int[] arr = new arr[10]; //声明一个int数组，数组有10个元素（每个）
2）int[] arr = 1,2,3,4,5; //声明和初始化一步完成，数组有5个

数组的初始化

两种形式：
1）动态初始化
int[] arr = new arr[10];
arr[0] = 10; 赋值，下标，索引值；arr[1] 第二元素，arr[length-1] 最后一个元素
2）静态初始化
int[] arr = 1,2,3,4,5;

package test;

import java.util.Arrays;	//Arrays在util工具包，导包

import org.junit.Test;

//数组
public class TestArray 
	@Test
	public void array() 
		//1、定义数组，数组长度8
		int[] arr = new int[8];	
		
		//2、数组初始化
		arr[0] = 10;	//通过下标访问第一元素
		arr[1] = 20;	//第二元素
		arr[7] = 30;	//最后一个元素
		
		//3、访问数组元素
		System.out.println(arr[0]);
		System.out.println(arr[7]);
		
		//4、打印整个数组
		//对象（引用类型）打印内存地址而不是具体内容 [I@780cb77
		System.out.println( arr ); //每个计算机它内存动态分配，地址不同
		
		//java数组本身没有提供直接打印数组方法，需要借助工具类 Arrays.toString()打印内容
		System.out.println( Arrays.toString( arr ));
	

对数组进行排序，打印内容

package test;

import java.util.Arrays;

import org.junit.Test;

//需求：科目：语文、数学、英语、物理、化学
public class TestCourse 
	@Test
	public void course() 
		String[] courses = "语文","数学","英语","物理";
		System.out.println("长度：" + courses.length);
		System.out.println("第一门课：" + courses[0]);
		System.out.println("第二门课：" + courses[1]);
		
		//System.out.println("最后一门课：" + courses[4]);
		//通过获取数组长度，代码更加灵活，写代码尽量不要写死
		System.out.println("最后一门课：" + courses[ courses.length-1 ]);
		
		//如果访问的下标超过了数组的长度-1，会报经典错误
		//ArrayIndexOutOfBounds 数组越界错误
	
	
	//记录上面每门课程的成绩，对成绩进行排序，数组没有排序功能，借助工具类Arrays.sort()
	@Test	
	public void sort() 
		int[] arrScores = 95, 115, 40;
		
		//对成绩进行排序
		System.out.println( Arrays.toString( arrScores ) );
		Arrays.sort(arrScores); //排序后会覆盖原有数组，升序（小在前，大在后）
		System.out.println( Arrays.toString( arrScores ) );
		
		//最高成绩
		System.out.println(arrScores[ arrScores.length-1 ]);
		
		//最低成绩
		System.out.println(arrScores[0]);
	

身高

package test;

import java.util.Arrays;

import org.junit.Test;

//需求：科目：语文、数学、英语、物理、化学
public class TestCourse 
	@Test
	public void course() 
		String[] courses = "语文","数学","英语","物理";
		System.out.println("长度：" + courses.length);
		System.out.println("第一门课：" + courses[0]);
		System.out.println("第二门课：" + courses[1]);
		
		//System.out.println("最后一门课：" + courses[4]);
		//通过获取数组长度，代码更加灵活，写代码尽量不要写死
		System.out.println("最后一门课：" + courses[ courses.length-1 ]);
		
		//如果访问的下标超过了数组的长度-1，会报经典错误
		//ArrayIndexOutOfBounds 数组越界错误
	
	
	//记录上面每门课程的成绩，对成绩进行排序，数组没有排序功能，借助工具类Arrays.sort()
	@Test	
	public void sort() 
		int[] arrScores = 95, 115, 40;
		
		//对成绩进行排序
		System.out.println( Arrays.toString( arrScores ) );
		Arrays.sort(arrScores); //排序后会覆盖原有数组，升序（小在前，大在后）
		System.out.println( Arrays.toString( arrScores ) );
		
		//最高成绩
		System.out.println(arrScores[ arrScores.length-1 ]);
		
		//最低成绩
		System.out.println(arrScores[0]);
	
	
	@Test //需求：身高数组，最高，最矮，平均(总高/长度)
	public void heigh() 
		double heighs[] = 180, 177, 188, 165, 190;
		
		//先排序
		Arrays.sort(heighs);
		System.out.println( Arrays.toString( heighs ));
		
		System.out.println("最高身高：" + heighs[heighs.length-1]);
		System.out.println("最矮身高：" + heighs[0]);
		
		//总身高
		double total = heighs[0] + heighs[1] + heighs[2] + heighs[3] + heighs[4];
		System.out.println("平均身高：" + total/heighs.length);
	
	

对象

数组也有问题，可以表达多个值，但是只能是一个类型，无法存储不同类型。
对象可以实现，它是万能，它能抽象生活中一切！！

需求：语文95，数学115，英语80
语文、数学、英语：字符串类型
95,115,80,：整数类型

对象+数组来实现
1）构建对象
Course course = new Course()；
类：Course，实例：course（c1,c2,c3）
属性：2个
课程名称：String name
成绩：Integer score

怎么保存三门课程呢？创建3个实例
Course c1 = new Course();
//使用.操作符访问属性
c1.name = "语文";
c1.score = 95;

Course c2 = new Course();
//使用.操作符访问属性
c2.name = "数学";
c2.score = 115;

Course c3 = new Course();
//使用.操作符访问属性
c3.name = "英语";
c3.score = 80;

2）对象数组