[Java知识库] java小白训练营day03-数据结构：基本类型+包装类型+数组+对象

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> java小白训练营day03-数据结构：基本类型+包装类型+数组+对象 -> 正文阅读

[Java知识库]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 （文件系统）
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);
	}
}