java小白训练营day03-数据结构：基本类型+包装类型+数组+对象
文章目录
-
- 程序
-
- 数据结构非常丰富
- java中把数据类型分类：
- 为什么java中要有基本类型呢？
- 基本类型
-
- 需求：有两个整数 100、200使用什么类型存储合适？
- 需求：有10亿（9个0）和100亿（10个0）区别？
- 类型转换
- 到底写一个值，它应该使用什么类型呢？
- 包装类型
-
- 取值范围
- 字符
- 包装类型意义把基本类型封装（包装）对象
- 字符集
- 数组
-
- 数组的定义
- 数组的初始化
- 对数组进行排序，打印内容
- 身高
- 对象
- 小结
-
- 最终代码
程序
程序员（新民工）
旧程序：数据结构+算法，老程序员关注的内容，计算机硬件水平落后（怎么节约内存，怎么加快计算速度，单机）
去大厂，关注基础扎实度，考核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 （文件系统）
1MB = 1024KB（文件系统）
1GB = 1024MB（文件系统）
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）对象数组
package cn.tedu.data;
//业务类：课程类
public class Course {
//属性，默认值null
public String name; //课程名称
public Integer score; //成绩
}
package test;
import org.junit.Test;
import cn.tedu.data.Course; //在不同包路径就需要导包
//测试课程类，必须先创建对象
public class TestCourseObject {
/*
* 步骤：
* 1、导入类，不同包路径就需要导入
* 2、创建new 实例 c1，
* 3、通过实例访问属性 c1.name、c1.score
* 4、初始化值
* 5、打印对象的属性值
*/
@Test
public void course() {
//格式：类名 实例名 = new 类名();
Course c1 = new Course();
c1.name = "语文"; //通过.操作符访问属性
c1.score = 95;
//cn.tedu.data.Course@23282c25
System.out.println(c1); //内存地址
System.out.println( c1.name );
System.out.println( c1.score );
}
}
小结
1）程序
a. 旧程序= 数据结构+算法（关注java语言）
b. 新程序= 数据结构+算法+框架+架构（关注ssm三大框架，互联网架构，微服务架构，大数据架构）
2）数据结构
怎么保存数据更加合理
100
int i = 100;
String s = “100”;
3）数据类型分类
a. 基础类型，放在栈中，方法结束，空间释放（手动）（及时释放资源）程序性能高
家里垃圾，自己扔出去
b. 引用类型（包装类型）、数组、对象，放在堆中，GC 垃圾回收器（java自己管理，自动，），复用
CG垃圾站，不知道什么时间清除，总有清除时候
4）java提供8个基本类型
byte/short/int/long/float/double/char/boolean
byte -128~127，256
short -32768~32767，65536
int ±21亿
char 2字节，ASCII/ISO-8859-1/ unicode utf-8 (1~3字节）
5）包装类型
a. 比基本类型增加了很多方法
b. 把基本类型转换成包装类型，那就可以享受对象
其他都是首字母大写，两个特殊：Integer、Character
6）数组
a. 定义 String[] s1 = new String[10]; String[] s2 = {1,2,3,4}; 推荐
b. 数组元素访问，通过下标index，从0开始
c. 工具类，打印数组内容和排序 Arrays.toString( arr); 和 Arrays.sort( arr)
7）对象
java一等公民，最重要，它抽象生活中万物 Object
a.创建对象 Cat cat = new Cat();
b. 访问属性 cat.name = “喵喵”; cat.age = 3;
最终代码
package cn.tedu.data;
//业务类：课程类
public class Course {
//属性，默认值null
public String name; //课程名称
public Integer score; //成绩
@Override
public String toString() {
return "Course [name=" + name + ", score=" + score + "]";
}
}
package test;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import cn.tedu.data.Course; //在不同包路径就需要导包
//测试课程类，必须先创建对象
public class TestCourseObject {
/*
* 步骤：
* 1、导入类，不同包路径就需要导入
* 2、创建new 实例 c1，
* 3、通过实例访问属性 c1.name、c1.score
* 4、初始化值
* 5、打印对象的属性值
*/
@Test
public void course() {
//格式：类名 实例名 = new 类名();
Course c1 = new Course();
c1.name = "语文"; //通过.操作符访问属性
c1.score = 95;
//cn.tedu.data.Course@23282c25
System.out.println(c1); //内存地址
System.out.println( c1.name );
System.out.println( c1.score );
Course c2 = new Course();
c2.name = "数学"; //通过.操作符访问属性
c2.score = 115;
//cn.tedu.data.Course@23282c25
System.out.println(c2); //内存地址
System.out.println( c2.name );
System.out.println( c2.score );
Course c3 = new Course();
c3.name = "英语"; //通过.操作符访问属性
c3.score = 80;
//cn.tedu.data.Course@23282c25
System.out.println(c3); //内存地址
System.out.println( c3.name );
System.out.println( c3.score );
System.out.println("---对象数组---");
List<Course> cs = new ArrayList<Course>();
cs.add(c1);
cs.add(c2);
cs.add(c3);
System.out.println(cs);
System.out.println(cs.get(0).name);
}
}