java小白训练营2109-day03-数据结构：基本类型+包装类型+数组+对象
Posted 长安紫薯
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java小白训练营2109-day03-数据结构：基本类型+包装类型+数组+对象相关的知识，希望对你有一定的参考价值。
文章目录
程序
程序员写程序的
旧的程序员：程序开发语言，追求“扣”，节约CPU、内存（32m*3）、磁盘资源（4.3g火球），扣每个字节（=8bit位） 数据结构，数据要占用小的存储空间。int a = 10（内存）; syso(a) 运行的更快：算法
网络（33.6k 猫，拨号）逐行
关注点：数据结构+算法
新的程序员：CPU，多核，内存（16g）、硬盘（1t 高速）、网络（千兆）
软件设计时就没有那么扣了，习惯小的就行，功能实现就行，速度能接受就行
框架（SSM SpringMVC+Spring+Mybatis）+架构（SpringCloud微服务+互联网架构nginx+redis+mycat+大数据架构）
关注点：数据结构+算法+框架…………+架构…………
java语言是最基础开发，框架（半成品），架构（已经很多内容进行优化）
盖房子：砖头、预制板、钢筋水泥柱子
数据结构
int a = 10;
String name = "陈晨";
程序在处理数据时，应该尽量占用小的存储空间，理论上越小越好，越小越快
把生活中的数据要抽象成计算机所能识别数据。
各个语言java，整型、小数、字符、布尔值（基本类型）、字符串、数组（一组，多个值）、对象、树、图
利用这些数据结构最终就能找到一个合适的数据存储方式
java中数据类型分类
1）基本类型：8种 int a = 10; （速度快）
2）引用类型：非基本类型都是引用类型，字符串String s= “陈晨”; 数组Arrays; 对象Object （速度慢）
java 是一个面向对象，把生活中的所有的内容都可以抽象成对象
八种基本类型
计算机最小单位bit比特，编程语言最小单位 byte 字节 1字节=8比特
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~4字节 UTF-8 ，全球代码unicode 4个字节 ASCII/ISO-8859-1/UTF-16/UTF-8
8）boolean 布尔型，就2个值true 1和false 0，bit/byte,1字节
案例：数字100和200使用什么类型来存储
要求：使用尽量小的存储类型 byte、short、int、long？
package cn.tedu.data;
//基本类型测试
public class TestPrimity {
public static void main(String[] args) {
//需求：100和200使用什么类型存储？
//Type mismatch: cannot convert from int to byte
//类型不匹配，不能转换整型到字节型
//默认写一个数字，java把它当成整型
//100也是整型，它在byte的存储的范围内，java自动转换类型
byte b = 100;
//byte b = 200; 就不能存储到byte中，超出范围
//在一个方法体不能声明同样名称
short b1 = 200;
System.out.println(b);
//需求：存储1九个0（10亿），1十个0（100亿）使用什么类型存储
int i1 = 1000000000; //在整数范围内容，可以存储
long i2 = 10000000000L; //不在整数范围内，必须用long，必须标识它是long，在数字后符号l/L
//结论：写一个数字尽量使用小的存储范围，习惯int；
}
}
字符
char c = ‘a’; //使用单撇括起来，只能一个字符，还可以是个整数
char c = 97;
package cn.tedu.data;
//字符
public class TestChar {
public static void main(String[] args) {
char c1 = '0';
System.out.println(c1);
char c2 = 48;
System.out.println(c2);
/*
* 结论：
* 发现一个规则，字符其实可以由一个定死整数来表达
* a 97
* b 98
* 0 48
* 规则：ASCII码表
* 把字母或者数字使用十进制表达，
* 进而可以把十进制转成二进制
* 人类识别语言，可以转换计算机识别二进制
*
* 键盘敲入a，在屏幕显示a
* 计算机接收到键盘输入a，把这个a转换97
* 然后把97转换二进制0110 0001（8bit）
* 计算机在内存中就可以存放 0110 0001
* 从内存中取出二进制，然后转换97，然后查询ASCII表
* 查询到97对应字母a，最后在屏幕上显示a
*/
}
}
常见的字符集
1）ASCII 标准信息交换码 128字符
2）ISO-8859-1 扩展了ASCII，加西欧和、符号，扩展256字符
3）GB2312 只支持中文简体，BIG5繁体，GBK
4）unicode 编码规则，字符集：UTF-32，每个字节都占4个字节，UTF-16，UTF-8 压缩 英文1个字节，中文3个字节，生僻字，繁体4个字节
现今文件编码，数据库编码，页面html网页编码都会，习惯都是要utf-8
包装类型
针对每个基本类型它就有一个包装类型，包装类型有8个
byte Byte，short Short，int Integer, long Long, float Float，double Double，char Character， boolean Boolean
怎么得到这些类型对应取值范围（整数、小数）
byte b1 = 100; //基本类型没有.操作符的
Byte b2 = 100; //包装类型，支持.操作符，支持额外方法，这些方法jdk
package cn.tedu.data;
//打印出所有基本类型的取值范围，4个整数，2个小数
public class TestScope {
public static void main(String[] args) {
System.out.println("byte范围："
+ Byte.MIN_VALUE+"~"+Byte.MAX_VALUE);
System.out.println("short范围："
+ Short.MIN_VALUE+"~"+Short.MAX_VALUE);
System.out.println("int范围："
+ Integer.MIN_VALUE+"~"+Integer.MAX_VALUE);
System.out.println("long范围："
+Long.MIN_VALUE+"~"+Long.MAX_VALUE);
System.out.println("float范围："
+Float.MIN_VALUE+"~"+Float.MAX_VALUE);
System.out.println("double范围："
+Double.MIN_VALUE+"~"+Double.MAX_VALUE);
//打印ASCII编码0（NUL）和127（del键）不可见字符
System.out.println("char范围："
+Character.MIN_VALUE+"~"+Character.MIN_VALUE);
//布尔没有最大值和最小值，只有TRUE和FALSE
System.out.println(Boolean.TRUE);
}
}
执行结果：
byte范围：-128~127
short范围：-32768~32767
int范围：-2147483648~2147483647
long范围：-9223372036854775808~9223372036854775807
float范围：1.4E-45~3.4028235E38
double范围：4.9E-324~1.7976931348623157E308
char范围：
在java中万物皆对象，包装类型都是对象Object
包装类型和对象Object有相关性？
在java中所有的类都有一个父亲 Object类，在java中所有类都是直接或者间接的继承Object类
它就享受到java对象的很多好处（额外方法）
Byte ~ Object
package cn.tedu.data;
//所有创建类可以明确声明继承哪个类，也可以不声明，不声明就继承Object
public class TestWrapper {
public static void main(String[] args) {
//获得Byte类（this）的父类（super）
//Long b = 100L;
//Double b = 100.0D;
//Character b = 'a';
Boolean b = true;
System.out.println("当前类："+b.getClass());
System.out.println("父类："+ b.getClass().getSuperclass());
System.out.println("爷类："+ b.getClass().getSuperclass().getSuperclass());
System.out.println("祖宗："+ b.getClass().getSuperclass().getSuperclass().getSuperclass());
// java.lang.NullPointerException 空指针错误
}
}
基本类型也好，包装类型也好
它们的缺点是只能存储一个类型的一个值。
//Type mismatch: cannot convert from int to Boolean
int i = 1000;
//Type mismatch: cannot convert from String to int
i = "tony"; //编译时会进行语法检查，强制看类型是否匹配
要存储多个值，数组
例子：科目，语文、数学、英语
String course1 = “语文”;
String course2 = “数学”;
String course3 = “英语”;
数组存取多个值
1）定义
2）初始化（设置）
a. 动态的初始化
b. 静态的初始化
3）获取数组，某个元素，下标
package cn.tedu.data;
//数组
public class TestArray {
public static void main(String[] args) {
//1. 定义
//创建一个字符串数组对象，长度3，可以存3个元素
//coures叫做instance 实例
String[] coures = new String[4];
//String coures[] = new String[3];
//2.1 动态的初始化，给里面的元素来设置值，通过数组下标
coures[0] = "语文"; //把下标为0的内容替换
coures[1] = "数学";
coures[2] = "英语";
//coures[3] 这个值超过数组的范围，如果调用就报错
//运行时 java.lang.ArrayIndexOutOfBoundsException
// index索引，下标越界
//System.out.println( coures[4] );
//2.2 静态的初始化
//3. 获取数组元素，打印
//每个人的电脑的内存使用不同，造成地址值是不同（正常）
//[Ljava.lang.String;@182decdb 内存地址
System.out.println( coures );
//获取元素时，通过数组的下标进行访问
System.out.println("数组的第一个元素："+ coures[0]);
System.out.println("数组的第二个元素："+ coures[1]);
System.out.println("数组的最后一个元素："+ coures[2]);
System.out.println("数组的长度：" + coures.length);
//下面的两种写法执行时间一致，这点时间差是可以忽略，推荐length-1，读代码清晰
//写代码时有个习惯：尽量写活
System.out.println("数组的最后一个元素："+ coures[3]);
System.out.println("数组的最后一个元素："+ coures[coures.length-1]);
}
}
package cn.tedu.data;
import java.util.*; //eclipse提示，导包
/*
* 得分：100,120,80,60,10
* 1）求总分 total，遍历数组获取所有值，然后全部加起来
* 2）求平均分 avg，总分/分个数 total/5
* 3）求最高分 max，排序，正序后，最后元素
* 4）求最低分 min，排序，正序后，第一个元素
*/
public class TestScores {
public static void main(String[] args) {
//定义，静态初始化数组
int[] scores = {100,120,80,60,10};
int total = scores[0]+scores[1]+scores[2]+scores[3]+scores[4];
int avg = total/scores.length;
//排序
Arrays.sort(scores);
int max = scores[scores.length-1];
int min = scores[0];
System.out.println( Arrays.toString(scores));
System.out.println("总计值：" + total);
System.out.println("平均值：" + avg);
System.out.println("最大值：" + max);
System.out.println("最小值：" + min);
}
}
对象
基本类型、包装类型只能表达一个类型一个值
数组虽然能表达多个值，但是每个元素的类型必须一致，只能是一个类型
需求：人特性
1）姓名 String
2）性别 Boolean
3）年龄 Integer
4）地址 String
java提供万能抽象的方式，把生活中万物都可以抽象出来，就是Object对象
对象的结构非常复杂，它就运行单个值支持，数组支持，不同的类型支持
完成抽象的过程
1、定义
1）创建 Person类
2）类中有很多特征（属性，字段，成员变量-类名下，属于类）
原则：成员变量推荐使用包装类型
a. 姓名 String name;
b. 性别 Boolean sex;
c. 年龄 Integer age;
d. 地址 String address;
2、使用
类要使用创建对象实例：类名 实例名 = new 类名();
Person person = new Person();
初始化，通过点操作符，对象的操作方式
person.name = “陈晨”;
person.sex = true; //true男，false女
person.age = 18;
person.address = “北京”;
3、访问、打印
syso( person.name );
package cn.tedu.entity;
//实体类：人Person
public class Person {
//特征，属性，成员变量（在类下面写的）
//局部变量（在方法中声明的变量）
//成员变量习惯使用包装类型来定义
public String name; //姓名
public Boolean sex; //性别
public Integer age; //年龄
public String address; //地址
}
package cn.tedu.data;
//不在同一个包路径下，需要导包 import
import cn.tedu.entity.Person;
//测试类
public class TestPerson {
public static void main(String[] args) {
//1. 创建对象实例
//类 实例 = new 类();
Person p = new Person();
//2. 属性初始化
p.name = "陈晨";
p.sex = true;
p.age = 18;
p.address = "北京";
//3. 打印某个属性
System.out.println(p);
System.out.println( p.name );
System.out.println( p.sex );
System.out.println( p.age );
System.out.println( p.address );
//Duplicate local variable p 局部变量重名了
Person p1 = new Person();
p1.name = "王强";
p1.sex = false;
p1.age = 16;
p1.address = "上海";
System.out.println(p1);
System.out.println(p1.name);
System.out.println(p1.sex);
System.out.println(p1.age);
System.out.println(p1.address);
}
}
以上是关于java小白训练营2109-day03-数据结构：基本类型+包装类型+数组+对象的主要内容，如果未能解决你的问题，请参考以下文章