【小白学java】java数据结构（day03）

课程链接：共六天

第一天：开发环境：初识java，搭建环境
第二天：语言基础：关键字、变量、常量、运算符
第三天：数据结构：基本类型、包装类型、引用类型（数组和对象）
第四天：流程控制：分支判断、循环迭代、异常处理
第五天：API工具类：字符串方法、身份证解析
第六天：面向对象：封装、继承、抽象、接口

什么叫程序？

传统程序 = 算法 + 数据结构

程序计算时要先把数据临时保存起来，方便程序后面代码对其访问进行算法演算，
怎么保存这些数据利用率高。整数？小数？字符？字符串？对象（人的信息=姓名+年龄+生日）
根据数据的特点把他用适合结构来存储。对应结构运算速度快（读取，存储速度）

现今程序 = 算法 + 数据结构 + 框架* + 架构*

框架：ssm三大框架：springmvc+spring+mybatis
架构：nginx+redis+mycat+rabbitmq+rocketmq+docker+k8s+ hadoop+flink + kafka

java如何去保存一个数据，有对应数据结构
分成两类：
1）基本类型：就8种基本类型，整数、小数、其它
2）引用类型：术语和c语言（最强大指针，引用谁就用指针指过去）
大白话：非基本类型就是引用类型！

从占用空间、性能触发，优先顺序：
优先使用整数，优先byte>short>int>long
小数：float>double
String>Array>Object
总结：在开发中使用局部变量优先基本类型变量，在成员变量 引用类型。

基本类型

8种基本类型

1）byte 字节，1个字节=8bit比特
2）short 短整型，2个字节
3）int 整型，4个字节，32b
4）long 长整型，8个字节，64b
5）float 单精度浮点型，4个字节
6）double 双精度浮点型，8个字节
7）char 字符型，2个字节
ascii 1个字节，2个字节
unicode/16 4个字节/utf-8 压缩 2个字节、3个字节、4个字节
8）boolean 布尔型，1字节

它们表达数值范围不同，一般采用所占用字节数表达。
特点：
1）在java中基本类型都必须小写
2）在内存中是连续空间，会浪费一定空间，以空间换时间
3）存储空间不够，空间翻倍
4）字符可以容纳1~4个字节
5）布尔类型也要占1个字节

基本类型都有默认值

引用类型的默认值null，但是基本类型都有自己的默认值：
1）整数： 0
2）小数：0.0
3）字符：u0000x（unicode）NUL ascii
4）布尔：false

package cn.tedu.data;

import org.junit.Test;

//打印8种基本类型的默认值
public class TestBasicDataType {
	//这个位置定义的变量就叫成员变量
	byte b;
	
	/*
	 * 加junit，@Test帽子，弹出选中JUnit4，自动导包import
	 * 默认值
	 */
	@Test
	public void defaultValue() {
		//规定：方法局部变量必须初始化才能打印
		//成员变量不初始化，使用默认值，在类下面定义的就叫成员变量
		//byte b;
		//The local variable b may not have been initialized
		System.out.println("byte 字节的默认值是：" + b);
	}
}

计算机怎么和人类沟通

人打键盘，输入字母，底层翻译二进制编码，编码规范就是ascii码。
NUL 0 （null）
a 97
A 65
0 48

包装类型

基本类型变量是无法直接知道它们最大值和最小值，取值范围。
java就推出包装类型，额外提供很多方法，其中就有MAX_VALUE最大值和MIN_VALUE最小值。

1）byte Byte
2）short Short
3）int Integer*
4）long Long
5）float Float
6）double Double
7）char Character*
8）boolean Boolean

包装类型就把基本类型变成对象 Object
c 语言面向过程，java语言面向对象，python 面向对象
java中第一公民：对象，万物皆对象。

基本类型存储大小

package cn.tedu.data;

import org.junit.Test;

//打印基本类型的范围
public class TestBasicTypeScope {
	@Test
	public void scope() {
		//包装类型可以直接获取最小值和最大值 -128（-2^7）~127（2^7），总共256=2^8，中间包括0
		System.out.println("Byte 范围：" + Byte.MIN_VALUE + "~" +Byte.MAX_VALUE);
		
		//-32768~32767，总共65536 = 64k = 64*1024
		System.out.println("Short 范围：" + Short.MIN_VALUE+"~"+Short.MAX_VALUE);
		
		//-21亿到21亿
		System.out.println("Integer 范围：" + Integer.MIN_VALUE+"~"+Integer.MAX_VALUE);
		
		System.out.println("Long 范围：" + Long.MIN_VALUE+"~"+Long.MAX_VALUE);
		
		//1.4E-45~3.4028235E38 科学计数法E-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();
		//如果写一个整数默认类型整型
		Byte b1 = 100;			//java自动将整数类型强制转换为Byte类型
		System.out.println(b1);
		
		//Type mismatch 类型不匹配: cannot convert from int to Byte
		//Byte b2 = 200;		//200超过byte范围，放不进去，报错
		//System.out.println(b2);
		
		//如果写一个小数默认类型双精度浮点数
		//Type mismatch: cannot convert from double to Float
		Float f = 1.1F;	//写1.1默认是double类型，在最后加f或者F，代表Float类型
		System.out.println(f);
	}
}

总结一句：
1）日常写一个整数默认 int类型，写一个小数默认 double类型
2）强制标识这个数值是什么类型：Long（l/L）、Float（f/F）、Double(d/D)

引用类型

数组

基本类型或者包装类型它们都只能表达一个值，如果想要表达一组值（多个值）怎么办呢?
使用数组：
int[] a = {10, 20, 30};
int[] a = new int[3];
a[0] =10;
a[1] = 20;
a[2] = 30;

package cn.tedu.data;

import java.util.Arrays;

import org.junit.Test;

//数组
public class TestArray {
	@Test
	public void intArray() {
		//定义int数组，数组有4个元素
		//每个元素的值0
		//数组的定义
		int[] a = new int[4]; 
		
		//数组元素值初始化
		a[0] = 10;
		a[1] = 20;
		a[2] = 30;
		
		System.out.println("数组的长度：" + a.length);
		//数组通过下标进行访问，下标起始0
		System.out.println("数组第一个元素："+ a[0] );
		System.out.println("数组最后一个元素：" + a[3]);  //不推荐
		
		//中括号中可以支持表达式，灵活，代码尽量不要写死
		System.out.println("数组最后一个元素：" + a[ a.length-1 ] );
		
		//一条代码做2件事情，创建b数组，同时初始化
		int[] b = {10, 20, 30, 0};
		//查看数组中元素，快捷工具类写法
		System.out.println( Arrays.toString(b) );
	}
}

数组排序、总计、平均值、最大值、最小值

package cn.tedu.data;

import java.util.Arrays;

import org.junit.Test;

//数组
public class TestArray {
	@Test
	public void intArray() {
		//定义int数组，数组有4个元素
		//每个元素的值0
		//数组的定义
		int[] a = new int[4]; 
		
		//数组元素值初始化
		a[0] = 10;
		a[1] = 20;
		a[2] = 30;
		
		System.out.println("数组的长度：" + a.length);
		//数组通过下标进行访问，下标起始0
		System.out.println("数组第一个元素："+ a[0] );
		System.out.println("数组最后一个元素：" + a[3]);  //不推荐
		
		//中括号中可以支持表达式，灵活，代码尽量不要写死
		System.out.println("数组最后一个元素：" + a[ a.length-1 ] );
		
		//一条代码做2件事情，创建b数组，同时初始化
		int[] b = {10, 20, 30, 0};
		//查看数组中元素，快捷工具类写法
		System.out.println( Arrays.toString(b) );
	}

	@Test	//定义数组、总计sum、平均值avg、最大值max、最小值min
	public void doArray() {
		int[] scores = {100, 99, 60, 88, 95};
		
		//总计
		int sum = 0;
		sum += scores[0];
		sum += scores[1];
		sum += scores[2];
		sum += scores[3];
		sum += scores[4];
		System.out.println("总计："+sum);
		
		//平均值=总计/数组长度
		int avg = sum / scores.length;
		System.out.println("平均值：" +avg);
		
		//先排序，正序（最小在前面），获取第一个元素最小值，最后一个元素最大值
		//Arrays.sort(a); 对数组a进行正序，排完结果存放回数组（原来数组就被覆盖）
		Arrays.sort(scores);
		System.out.println( Arrays.toString(scores)  ); //scores数组的内容已经被排序了
		
		//最大值（数组的最后一个元素）
		System.out.println( "最大值：" + scores[ scores.length-1 ] );
		
		//最小值（数组的第一个元素）
		System.out.println("最小值：" + scores[0] );
	}
}

数组

1）数组array它可以存放多个值，但必须每个值都是一个类型。
2）new关键字创建数组对象，它不是基本类型，它是引用类型。
3）工具类：jdk Arrays
Arrays.toString(array); 把数组转换字符串
Arrays.sort(array) 对array进行排序，排序后覆盖array，在sort前的数组的内容在sort被改变。

缺点：多个值的类型只支持一个。生活中很复杂：表示一个人的信息（姓名 String、年龄 int/short/byte、生日 date）
如果它能实现，就可以表达生活中万物！

对象

在java中万物皆对象 Object
1）怎么证明java中万物皆对象
a. 所有java创建非基本类型变量都是Object的子类。
如果你自己写的类没有明确继承 extends Object，java在编译时会自动填上。任何Java类都是Object子类？
看看包装类型它的父类是谁？Object?

package cn.tedu.data;

import java.util.Arrays;

import org.junit.Test;

//数组
public class TestArray{
	@Test
	public void intArray() {
		//定义int数组，数组有4个元素
		//每个元素的值0
		//数组的定义
		int[] a = new int[4]; 
		
		//数组元素值初始化
		a[0] = 10;
		a[1] = 20;
		a[2] = 30;
		
		System.out.println("数组的长度：" + a.length);
		//数组通过下标进行访问，下标起始0
		System.out.println("数组第一个元素："+ a[0] );
		System.out.println("数组最后一个元素：" + a[3]);  //不推荐
		
		//中括号中可以支持表达式，灵活，代码尽量不要写死
		System.out.println("数组最后一个元素：" + a[ a.length-1 ] );
		
		//一条代码做2件事情，创建b数组，同时初始化
		int[] b = {10, 20, 30, 0};
		//查看数组中元素，快捷工具类写法
		System.out.println( Arrays.toString(b) );
	}

	@Test	//定义数组、总计sum、平均值avg、最大值max、最小值min
	public void doArray() {
		int[] scores = {100, 99, 60, 88, 95};
		
		//总计
		int sum = 0;
		sum += scores[0];
		sum += scores[1];
		sum += scores[2];
		sum += scores[3];
		sum += scores[4];
		System.out.println("总计："+sum);
		
		//平均值=总计/数组长度
		int avg = sum / scores.length;
		System.out.println("平均值：" +avg);
		
		//先排序，正序（最小在前面），获取第一个元素最小值，最后一个元素最大值
		//Arrays.sort(a); 对数组a进行正序，排完结果存放回数组（原来数组就被覆盖）
		Arrays.sort(scores);
		System.out.println( Arrays.toString(scores)  ); //scores数组的内容已经被排序了
		
		//最大值（数组的最后一个元素）
		System.out.println( "最大值：" + scores[ scores.length-1 ] );
		
		//最小值（数组的第一个元素）
		System.out.println("最小值：" + scores[0] );
	}
	
	@Test
	public void arrayType() {
		int b = 10;
		int[] a = new int[5];
		
		System.out.println(b);			//基本类型，直接打印值
		System.out.println(a);			//打印这个对象的内存地址 [I@7506e922（引用的指针）
		System.out.println(a[0]);		//打印第一个元素值 0
	}
}

总结：

1）万物皆Object对象
2）打印引用类型实例时，这个对象的toString()方法。如果这个类没有写这个方法，它调用Object.toString(）。

2）创建人这个对象

人：姓名+年龄+生日

package cn.tedu.data;

import java.util.Date;	//不能选择java.sql.Date会报错，必须选择util

/*
 * 人：类
 */
public class Person {
	//成员变量：属性
	String name;	//姓名
	int age;			//年龄
	Date birthday;	//生日
}

package cn.tedu.data;

import java.util.Date;

import org.junit.Test;

//测试类
public class TestPersonCar {
	@Test	//测试人
	public void person() {
		//格式：类名 对象实例名 = new 类名();
		//男人，对象，从类去创建对象实例
		Person man = new Person();
		
		//怎么访问对象属性，通过.操作符
		man.name = "王强";
		man.age = 28;
		man.birthday = new Date();	//简便，当前日期
		
		System.out.println("姓名：" + man.name );
		System.out.println("年龄：" + man.age );
		System.out.println("生日：" + man.birthday );
		
		//女人，对象，通过类可以产生n个对象
		Person woman = new Person();
		woman.name = "李颖";
		woman.age = 18;
		woman.birthday = new Date();
		
		System.out.println("姓名：" + woman.name );
		System.out.println("年龄：" + woman.age );
		System.out.println("生日：" + woman.birthday );
	}
}

车：类型+颜色+价格

package cn.tedu.data;

//类：车
public class Car {
	//属性，成员变量
	String type;		//类型
	String color;		//颜色
	Double price;	//价格
}

package cn.tedu.data;

import java.util.Date;

import org.junit.Test;

//测试类
public class TestPersonCar {
	@Test	//测试人
	public void person() {
		//格式：类名 对象实例名 = new 类名();
		//男人，对象，从类去创建对象实例
		Person man = new Person();
		
		//怎么访问对象属性，通过.操作符
		man.name = "王强";
		man.age = 28;
		man.birthday = new Date();	//简便，当前日期
		
		System.out.println("姓名：" + man.name );
		System.out.println("年龄：" + man.age );
		System.out.println("生日：" + man.birthday );
		
		//女人，对象，通过类可以产生n个对象
		Person woman = new Person();
		woman.name = "李颖";
		woman.age = 18;
		woman.birthday = new Date();
		
		System.out.println("姓名：" + woman.name );
		System.out.println("年龄：" + woman.age );
		System.out.println("生日：" + woman.birthday );
	}

	@Test	//测试汽车类
	public void car() {
		//保时捷911、红色、640000
		
		//1、创建对象实例
		Car car = new Car();	
		
		//2、设置属性
		car.type = "保时捷911";	
		car.color = "红色";
		car.price = 640000D;	//通过D声明它是一个double类型
		
		//3、访问属性
		System.out.println( "类型：" + car.type );
		System.out.println( "颜色：" + car.color );
		System.out.println( "价格：" + car.price );
	}
}

知识回顾

数据类型

基本类型

包装类型