【小白学java】java数据结构（day03）
什么叫程序？
传统程序 = 算法 + 数据结构
程序计算时要先把数据临时保存起来，方便程序后面代码对其访问进行算法演算，
怎么保存这些数据利用率高。整数？小数？字符？字符串？对象（人的信息=姓名+年龄+生日）
根据数据的特点把他用适合结构来存储。对应结构运算速度快（读取，存储速度）
现今程序 = 算法 + 数据结构 + 框架* + 架构*
框架：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 );
}
}