java小白训练营day03-数据结构:基本类型+包装类型+数组+对象

Posted 长安紫薯

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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)对象数组

以上是关于java小白训练营day03-数据结构:基本类型+包装类型+数组+对象的主要内容,如果未能解决你的问题,请参考以下文章

java小白训练营day03-数据结构:jUnit+基本类型+包装类型+数组+对象

java小白训练营day03-数据结构:jUnit+基本类型+包装类型+数组+对象23

202106小白训练营day03-java数据结构

java小白训练营2109-day03-知识回顾

java小白训练营day03-知识回顾

java小白训练营day03-知识回顾