JavaDay05
数据类型及拓展
public class Demo01 {
public static void main(String[] args) {
//进制拓展： 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010;//八进制0
int i3 = 0x10;//十六进制0x 0~9 A~F 16
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("===================");//打印分隔符
//浮点数拓展，浮点数类型不能使用计算
//浮点数 舍入误差，有限 离散 接近但不等于 要避免使用浮点数进行比较
//避免使用浮点数进行比较和计算
//Bigdecimal 数学工具，使用该类进行数学计算
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);
System.out.println(f);
System.out.println(d);
//字符拓展，字符有对应的字符表，底层也是数字
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println(c2);
System.out.println((int)c2);//强制转换为int类型
//输出看看 会发现有数字出现
//所有的字符 本质还是数字，Unicode编码 2个字节 65536
}
}
类型转换
java是强类型语言，所以要进行有些的时候，需要用到类型转换
低------------------------------------高
byte,short,char-> int-> long-> float-> double
运算中，不同类型的数据先转换为同一类型，然后才能进行计算
public class Demo02 {
public static void main(String[] args) {
int i = 128;
byte b = (byte) 128;//该方法是强制转换，超出范围的会内存溢出
System.out.println(i);
System.out.println(b);
//强制转换 （类型）变量名 高--低
//自动转换 低--高
/*注意点
1、不能对布尔值进行转换
2、不能把对象类型转换为不相干的类型
3、高容量转换为低容量，强制转换
4、转换的时候可能存在内存溢出，或精度问题
*/
//操作比较大的数字，注意溢出问题
//JDK7 新特性，数字之间可以用下划线分隔
int money = 10_0000_0000;
int years = 20;
int total = money*years;
System.out.println(total);//输出了-1474836480，明显是不对的
//int 的计算 结果还是int类型，这里的计算已经内存溢出了
long total3 = money*((long)years);//先把一个数转换为long
System.out.println(total3);//这里的输出就是正确的了
}
}
变量、常量、作用域
变量：就是可以变化的量！
Java中，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
变量作用域：
类变量
实例变量
局部变量
public class Variable{
static int allClicks=0; //类变量
String str ="hello world"; //实例变量
public void method(){
int i = 0; //局部变量
}
}
public class Demo02 {
//类变量 static
static double salary = 2500;
//属性：变量
//实例变量：从属于对象；如果不自行初始化，这个类型的默认值 0 0.0
//布尔值，默认是false
//除了基本类型，其余的默认值都是null;
String name;
int age;
//main 方法
public static void main(String[] args) {
//局部变量：在方法里面，必须声明和初始化值，没有赋值是没法输出
int i = 10;
System.out.println(i);//这里才能输出
//变量类型 变量名字 = new Demo02（）;
Demo02 demo2 = new Demo02();
System.out.println(demo2.age);
System.out.println(demo2.name);
//类变量 static
System.out.println(salary);
}
//其它方法
public void add(){
}
}
常量：初始化后不能改变值！不会变动的值。
final 常量名=值; final double PI = 3.14;
变量的命名规范
-
所有的变量、方法、类名：见名如意
-
类成员的变量：首字母和驼峰原则：monthSalary第一个单词小写外，后面的单词首字母大写
-
局部变量：首字母小写和驼峰原则
-
变量：大写字母和下划线：MAX_VALUE
-
类名：首字母大写和驼峰原则：Man, GoodMan
-
方法名：首字母小写和驼峰原则：run(), runRun()
数组
数组是一个固定长度，包含了相同类型数据的容器
步骤：
声明数组
int[] a; 声明了一个数组变量。 []表示该变量是一个数组 int 表示数组里的每一个元素都是一个整数 a 是变量名 但是，仅仅是这一句声明，不会创建数组
有时候也会写成int a[]; 没有任何区别，就是你看哪种顺眼的问题
public class HelloWorld {
public static void main(String[] args) {
// 声明一个数组
int[] a;
}
}
创建数组
创建数组的时候，要指明数组的长度。 new int[5] 引用概念： 如果变量代表一个数组，比如a,我们把a叫做引用 与基本类型不同 int c = 5; 这叫给c赋值为5 声明一个引用 int[] a; a = new int[5]; 让a这个引用，指向数组
public class HelloWorld {
public static void main(String[] args) {
//声明一个引用
int[] a;
//创建一个长度是5的数组，并且使用引用a指向该数组
a = new int[5];
int[] b = new int[5]; //声明的同时，指向一个数组
}
}
访问数组
数组下标基0 下标0，代表数组里的第一个数
public class HelloWorld {
public static void main(String[] args) {
int[] a;
a = new int[5];
a[0]= 1; //下标0，代表数组里的第一个数
a[1]= 2;
a[2]= 3;
a[3]= 4;
a[4]= 5;
}
}
数组长度
.length属性用于访问一个数组的长度 数组访问下标范围是0到长度-1 一旦超过这个范围,就会产生数组下标越界异常
public class HelloWorld {
public static void main(String[] args) {
int[] a;
a = new int[5];
System.out.println(a.length); //打印数组的长度
a[4]=100; //下标4，实质上是“第5个”，即最后一个
a[5]=101; //下标5，实质上是“第6个”，超出范围 ,产生数组下标越界异常
}
}
练习数组最小值
首先创建一个长度是5的数组 然后给数组的每一位赋予随机整数 通过for循环，遍历数组，找出最小的一个值出来
0-100的 随机整数的获取办法有多种，下面是参考办法之一:
(int) (Math.random() * 100) //随机整数获取方法 //Math.random() 会得到一个0-1之间的随机浮点数，然后乘以100，并强转为整型即可。
public class Demo02 {
public static void main(String[] args) {
int[] a = new int[5];//长度为5的数组
a[0] = (int) (Math.random()* 100);//[0]数组的下标进行访问数组
a[1] = (int) (Math.random()* 100);
a[2] = (int) (Math.random()* 100);
a[3] = (int) (Math.random()* 100);
a[4] = (int) (Math.random()* 100);
System.out.println("数组中的各个随机数是：");
for (int i = 0; i < a.length; i++)
System.out.println(a[i] +" ");
System.out.println();
int min = 1000;
for (int i = 0; i < a.length; i++){
if ( a[i] <min)
min = a[i];
}
System.out.println("找出来的最小数值是：" +min);
}
}
public class Demo02 {
public static void main(String[] args) {
int arr[] = new int[5];
int min = 101;
System.out.println("数组中的各个随机数是：");
for (int i=0; i < arr.length; i++){
arr[i] = (int)(Math.random()*100);
System.out.println(arr[i]);
if (arr[i] < min){
min = arr[i];
}
}
System.out.println("最小值为："+min);
}
}
小习题：获取随机5个100以内的整数，并找出最小值和最大值
public class Demo02 {
public static void main(String[] args) {
//获取随机5个100以内的整数并找出最小值
/*获取最值需要进行比较，每一次比较都会有一个较大值，因为该值不确定，需要一个
变量进行临储。
让数组中的每一个元素都和这个变量中的值进行比较，如果大于 变量的值，就用该变量
记录较大值
当所有的元素都比较完成，那么该变量中存储的就是数组最大值
*/
int[] a = new int[5];
int max = 0;
int min = 100;
for (int i = 0; i < a.length; i++){
a[i] = (int)(Math.random()*100); //随机获取整数的方法
System.out.println(a[i]);
if (max < a[i]){
max = a[i];
}
if (min > a[i]){
min = a[i];
}
}
System.out.println("最大值：" +max);
System.out.println("最小值：" +min);
}
}
初始化数组
分配空间与赋值分布进行
public class HelloWorld {
public static void main(String[] args) {
int[] a = new int[5]; //分配了长度是5的数组，但是没有赋值
//没有赋值，那么就会使用默认值
//作为int类型的数组，默认值是0
System.out.println(a[0]);
//进行赋值
a[0] = 100;
a[1] = 101;
a[2] = 103;
a[3] = 120;
a[4] = 140;
}
}
分配空间，同时赋值
public class Demo03 {
public static void main(String[] args) {
int[] a = new int[5]; //分配了长度是5的数组，但没有赋值
System.out.println(a[0]); //默认初始化 作为int类型的数组，默认值是0
//进行赋值 操作
a[0] = 100;
a[1] = 101;
a[2] = 102;
a[3] = 103;
a[4] = 104;
System.out.println(a[4]);
//第2中 分配空间，同时赋值
//方法一： 分配空间，同时赋值
int[] a = new int[]{100,102,444,836,3236};
//方法二： 省略了new int[],效果一样
int[] b = {100,102,444,836,3236};
//方法三： 同时分配空间，和指定内容
/*
在这里给出的例子，长度是3，内容是5个，产生了矛盾
所以如果指定了数组的内容，就不能同时设置设置的长度了
*/
int[] c = new int[3]{100,102,444,836,3236}; //这里给了长度，也指定了内容，矛盾了
int[] d = new int[]{100,102,444,836,3236}; //这才是正确
int[] e = {100,102,444,836,3236}; //表述方式不一样
}
}
首先创建一个长度是5的数组,并填充随机数。 (向数组填充随机数的办法，参考这里)
使用for循环或者while循环，对这个数组实现反转效果
public class Demo03 {
public static void main(String[] args) {
/*
首先创建一个长度是6的数组，并填充随机数
使用for循环或者while循环，对这个数组实现反转效果
*/
int []arry = new int[6]; //填充随机数
for (int i = 0; i < arry.length; i++){
arry[i] = (int)(Math.random()*100);
System.out.println(arry[i]+"\t");
}
//数组反转
for (int i = 0; i < arry.length/2; i++){
int k = arry[i];
arry[i] = arry[arry.length-1-i];
arry[arry.length-1-i] = k;
}
System.out.println();
//输出反转后的数组
for (int i = 0; i < arry.length; i++){
System.out.println(arry[i]+"\t");
}
}
}
数组排序
选择法排序：
-
把第一位和其它所有的进行比较，只要比较第一位小的，就换到第一个位置来，比较完后，第一位就是最小的
-
然后再从第二位和剩余的其它所有进行比较，只要比第二位小，就换到第二位来，比较完成后，第二位就是第二小的
public class Demo03 { public static void main(String[] args) { //数组的排序，选择排序法 //把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来 //比较完后，第一位就是最小的 int a[] = new int[]{18,62,68,82,65,9}; //排序前，先把内容打印出来 for (int i = 1; i < a.length; i++) { if(a[i]<a[0]){ int temp = a[0]; a[0] = a[i]; a[i] = temp; } } //把内容打印出来 //可以发现，最小的一个数，到了最前面 for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); } System.out.println(" "); //第二步：把第二位的和剩下的所有位进行比较 for (int i = 2; i < a.length; i++){ if (a[i] < a[1]){ int temp = a[1]; a[1] = a[i]; a[i] = temp; } } for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); } System.out.println(" "); //打印发现，倒数第二小 已经到第二个位置了 /* 规律：移动的位置是从角标0,开始的，即第一位开始 所以可以在外面套一层循环 */ for (int j = 0; j < a.length-1; j++) { for (int i = j+1; i < a.length; i++) { if(a[i]<a[j]){ int temp = a[j]; a[j] = a[i]; a[i] = temp; } } } //把内容打印出来 for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); } System.out.println(" "); } }
冒泡法排序
-
从第一位开始，把相邻的两位进行比较
-
发现前面的比后面大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的
public class Demo03 { public static void main(String[] args) { //排序前，先把内容打印出来 int a [] = new int[]{18,62,68,82,65,9}; for (int i = 0; i < a.length; i ++){ System.out.println(a[i] + " "); } System.out.println(" "); /* 冒泡排序法 第一步：从第一位开始，把相邻的两位进行比较 如发现前面的比后面大，把大的交换到后面 */ for (int i = 0; i < a.length-1; i++){ if (a[i]>a[i+1]){ int temp = a[i]; a[i] = a[i+1]; a[i+1] = temp; } } for (int i = 0; i <a.length; i++){ System.out.println(a[i] + " "); } System.out.println(" "); //打印出来，发现最大的到了最后面 //第二步： 再来一次，只不过不用比较最后一位 for (int i = 0; i < a.length-2; i++) { if(a[i]>a[i+1]){ int temp = a[i]; a[i] = a[i+1]; a[i+1] = temp; } } //把内容打印出来 //可以发现，倒数第二大的到了倒数第二个位置 for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); } System.out.println(" "); /* 到这里，可以发现，后面的边界在收缩 所以 可以使用外面套一个循环 */ for (int j = 0; j < a.length; j++){ for (int i = 0; i < a.length-j-1; i++){ if (a[i] > a[i+1]){ int temp = a[i]; a[i] = a[i+1]; a[i+1] = temp; } } } for (int i = 0; i < a.length; i++){ System.out.println(a[i] + " "); } System.out.println(" "); } }
练习题：
public class Demo03 {
public static void main(String[] args) {
/*
首先创建一个长度是5的数组,并填充随机数。
首先用选择法正排序，然后再对其使用冒泡法倒排序
*/
//第一步，创建数组，长度是5
int a[] = new int[]{3,62,78,98,14};
//第二步，打印数组出来查看内容
for (int i = 0; i < a.length; i++){
System.out.println(a[i] + " ");
}
System.out.println(" ");
//使用 选择法排序，正序
for (int j = 0; j < a.length-1; j++){
for (int i = j+1; i < a.length; i++){
if (a[i] < a[j]){
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
for (int i = 0; i < a.length; i++){
System.out.println(a[i] + " ");
}
System.out.println(" ");
//冒泡排序法，倒序
for (int j = 0; j < a.length; j++){
for (int i = 0; i < a.length-1; i++){
if (a[i] < a[i+1]){ //倒序，把 > 号换成 <
int temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}
}
}
for (int i = 0; i < a.length; i++){
System.out.println(a[i] + " ");
}
System.out.println(" ");
}
}
数组 增强型for循环
增强型for循环在遍历一个数组的时候会更加快捷
-
注：增强型for循环只能用来取值，却不能用来修改数组里的值
public class HelloWorld { public static void main(String[] args) { int values [] = new int[]{18,62,68,82,65,9}; //常规遍历 for (int i = 0; i < values.length; i++) { int each = values[i]; System.out.println(each); } //增强型for循环遍历 for (int each : values) { //for(int each : 名称) each每一个 System.out.println(each); //输出打印每一个的意思 } } } -
练习题：用增强型for循环找出最大的那个数
-
public class 增强型for求数组最值 { public static void main(String[] args) { System.out.println("生成随机数组："); int[] a = new int[5]; for (int i = 0; i < a.length; i++) { a[i] = (int) (Math.random() * 100); System.out.print(a[i] + " "); } System.out.println(); int max = 0; for (int m : a) { if (m > max) { max = m; } } System.out.println("此数组的最大值是：" + max); } }
43
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
