/**
- 数组的定义
- 概念:同一种数据类型的集合,其实数组就是一个容器
- 数组的好处:可以自动给数组的元素从0开始编号,方便操作这些元素
- 格式一、
- 元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
- 示列: int [] arr = new int [5];
- 格式二、
- 元素类型[] 数组名 = new 元素类型[]{元素,元素,元素。。。。。};
- 示例:int[] arr = new int[3,4,5,6,7];
- int[] arr = {3,5,1,7};
- 内存结构:
- JAVA在运行时,需要在内存中分配空间。为了提高运算效率,有对空间进行了
- 不同区域的划分,因为每一篇区域都有特定的处理数据方式和内存管理方式
- 1.栈内存:用于存储局部变量,当数据使用完,所占的空间会自动释放
- 2.堆内存:
-
数组和对象,通过new建立的实列都存放在堆内存中
-
每一个实体都有默认初始化值
-
实体不再被使用,会在不确定时间内被垃圾回收器回收
- 3.方法区,本地方法区,寄存器
- 4.new出来的都是实体,都存放在堆里面产生了空间,这个空间就是数组
- 5.数组一旦被定义,数组都有默认初始化值 int型 默认 0 float默认 0.0
-
double型默认 0.00 boolend false
- 6.数组的赋值 x[角标] = 值;
-
- x =null;当一个实体在堆内存中没有任何引用所使用它的话,java虚拟机就视为它为垃圾
- 这个垃圾不会立刻被清理掉,而是在不定时的时间内启动一个垃圾回收机制,将这个数组实体在
- 堆内存中清除。
- 堆内存的三个特点
-
1.内存地址值
-
2.默认初始化值
-
3.垃圾回收机制
- 数组中在操作时常见的问题
*1、数组角标越界异常(arrayIndexOutofBounddsException):操作数组时访问到了数组中不存在的角标就会发生异常.
*2、空指针异常(NULL pointerException),arr中不具备任何实体,当引用没有任何指向值为null的情况, -
该引用还在用于操作实体
*2.8.5 数组中的数组(二维数组)
-
格式一:int[][] arr = new int[3][2];
-
定义了名称为arr的二维数组
-
二维数组中有3个一维数组
-
每一个一维数组中有两个元素
-
一维数组的名称分别是arr[0],arr[1],arr[2]
-
给第一个一维数组1角标位赋值为 78 的写法是 arr[0][1] = 78;
-
格式二:int[][] arr = new int[a][];
-
二维数组中有三个一维数组
-
每个一维数组都是默认初始化值NULL
-
可以对这三个一维数组分别进行初始化
-
arr[0] = new int[3];
-
arr[1] = new int[1];
-
arr[2] = new int[2];
-
二维数组中的长度arr.length
*定义格式
-
一维数组: int[] x; int x[];
-
二维数组:int[][] y; int y[][]; int[] y[];
*中括号放哪都行
*练习:int[] x,y[]; //x一维,y二维
*int[] x;
*int[] y[];
*下面那个答案是对的?
*
*a. x[0] = y; //error : 把二维数组赋值给一维数组中的元素
*b. y[0] = x; //yea 把一个一维数组赋值给二维数组
*c. y[0][0] = x; //error 把一个一维数组赋值给二维数组中的一个元素
*d. x[0][0] = y; //error x根本不是二维数组
*e. y[0][0] = x[0]; // 元素赋值给元素
*f. x = y; //error
- */
package 黑马程序员;
import java.util.*;
public class day_04 {
public static void main(String[] args)
{
//格式一、
//元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
//定义一个可以存储三个整数二点容器
int[] x = new int[3]; //x为数组类型
int[] y = {0,1,2,3,2};
x[2] = 2;
//打印数组中角标为0的元素的值
System.out.println(x[2]);
//实验两个引用指向了同一个对象或者同一个数组:判断有没有垃圾
//解答:没有垃圾
int [] z = new int [3];
int [] h = z;
h[1] = 89;
System.out.println(z[1]); // 89
z = null;
//格式二、静态初始化方式
int[] arr = new int[]{3,1,6,5,4};
//数组的操作
//获取数组中的元素。通常会用到遍历
int[] brr = {3,4,5,6,7,8,9,10,-1,2,3,1,156};
brrMAXMIN(brr);//求brr数组的最值
//数组中有一个属性可以直接获取到数组元素个数,length.
//使用方式:数组名称.length = 数组
System.out.print(brr.length);
for(int i = 0; i < brr.length; i++) {
System.out.print(brr[i]);
}
//printArray(arr);//遍历
int[] crr = {1,3,-1,5,7,8,10,7,6};
//selectSort(crr); //数组的排序
// printArray(crr); //遍历
selectsort1(crr);
// printArray(crr);
//System.out.println(crr.length);
//Arrays.sort(crr);
printArray(crr); //java自带的排序方法真实开发其实就是用Arrys.sort(数组名),前面必须声明:imoprt java.util.*;
//StringBuffer se = new StringBuffer();//声明容器
System.out.println();
//toHex(60); //二进制转换成十六进制
//求一个十进制的二进制形式
//toBin(16); //十进制转换二进制
//sze(-6); //十进制转二进制
//toHex1(-60); //负数的十进制转十六进制
// toEr(15); //优化后
// toBa(15); //优化后
// toShiLiu(15); //优化后
//System.out.print(Integer.toBinaryString(60)); //转换成二进制的
//二维数组
ArrSum();
}
//数组遍历类
public static void printArray(int[] arr) {
System.out.print("[ ");
for(int e = 0; e<arr.length ; e++) {
if(e != arr.length-1)
System.out.print(arr[e] + ", ");
else
System.out.println(arr[e] + " ]");
}
}
//求数组最值
public static void brrMAXMIN(int[] brr) {
int max,min,t;
max = min = brr[0];
for(int i = 0 ; i<brr.length ; i++) {
if(brr[i] > max)
max = brr[i];
if(brr[i] < min)
min = brr[i];
}
System.out.println("max " + max);
System.out.println("min" + min);
}
//对给定数组进行排序(选择排序)
//选择排序特点:内循环结束一次,最值出现头角标位置上
public static void selectSort(int[] crr) {
int min;
for(int i = 0; i<crr.length - 1 ; i++) { //几个数比较第一次比较n-1次
for(int j = i+1 ; j<crr.length ; j++) {
if(crr[i]>crr[j]) {
min = crr[i];
crr[i] = crr[j];
crr[j] = min;
}
}
}
}
//对给定数组进行排序(冒泡排序)
//相邻的两个元素进行比较符合条件就换位
public static void selectsort1(int[] err) {
int max;
for(int i = 0; i < err.length-1 ; i++) {
for(int j = 0 ; j < err.length - i -1;j++) { //err.length - i - 1是为了防止数组越界问题
if(err[j] > err[j+1]) {
// max = err[j];
// err[j] = err[j+1];
// err[j+1] = max;
swap(err,j,j+1); //把数组的两个数互换封装成一个类
}
}
}
}
//发现无论什么排序。都需要对满足条件的元素进行位子置换
//所以可以把这部分相同的代码提取出来,单独封装成一个函数;
//数组互换函数
public static void swap(int[] arr,int a,int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//十进制转换成二进制
public static void toBin(int num) {
StringBuffer sb = new StringBuffer(); //对象:存数据的
while(num>0) {
//System.out.print(num%2);
sb.append(num%2);
num = num / 2;
}
System.out.println(sb.reverse());
}
//十进制转换成16进制
public static void toHex(int num) {
StringBuffer se = new StringBuffer();
for(int x = 0 ; x<8 ; x++) {
int temp = num & 15;
if(temp > 9) {
//System.out.println((char)(temp - 10 + 'A'));
se.append((char)(temp - 10 + 'A'));
}
else {
//System.out.println(temp);
se.append(temp);
}
num = num>>>4;
}
System.out.println(se.reverse());
}
//十进制转换成16进制(查表法)
//查表法:将所有的元素临时存储起来,建立对应关系,每一次&15后的值作为索引去查
//建立好的表,可以找对应的元素
//下面出结果了 但是是反着的 想要正过来可以通过StringBuffer reverse功能来完成也可以通过数组来完成
//下面就是通过数组来完成反转
//字符数组在内存中一被定义它的默认初始化值是\u0000空位
/*
* 0 1 2 3 4 5 6 7 8 9 A B C D E F == 十六进制中的元素
* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
* */
public static void toHex1(int num)
{
char[] arr = new char[8];
char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
//int pos = 0;
int pos = arr.length-1;
while(num!=0){
int temp = num & 15;
//arr[pos++] = chs[temp];
arr[--pos] = chs[temp];
//System.out.println(chs[temp]);
num = num >>> 4;
}
// for(int x = pos-1; x >= 0 ; x--) { //pos - 1 指针存完3以后自增了一 回
// System.out.print(arr[x]);
// }
//倒着打印
for(int x = pos;x<arr.length;x++ ) { //从pos开始遍历
System.out.print(arr[x]);
}
}
//十进制转换成二进制(查表法)
public static void sze(int num) {
//定义二进制的表
char[] chs = {'0','1'};
//定义一个临时存储容器
char[] arr = new char[32]; //int类型32位二进制
//定义一个操作数组的指针
int pos = arr.length;
while(num!=0) {
int temp = num & 1;
arr[--pos] = chs[temp];
num = num >>> 1;
}
for(int x = pos; x<arr.length ; x++) {
System.out.print(arr[x]);
}
}
/*
* 十进制 --》 二进制
*/
public static void toEr(int num) {
trans(num,1,1);
}
/*
*十进制 --》 八进制
*/
public static void toBa(int num) {
trans(num,7,3);
}
/*
*十进制 --》 十六进制
*/
public static void toShiLiu(int num) {
trans(num,15,4);
}
//优化
public static void trans(int num,int base,int offset) {
if(num == 0) {
System.out.println(0); //如果为0直接返回0并退出这个类
return ;
}
char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] arr = new char[32];
int pos = arr.length;
while(num !=0) {
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
for(int x = pos; x < arr.length ; x++) {
System.out.print(arr[x] + " ");
}
}
//二维数组的练习:求公司中的各组的销售和
public static void ArrSum() {
int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int sum = 0;
for(int i = 0 ; i<arr.length ; i++) {
for(int j =0 ; j<arr[i].length ; j++) {
sum = sum + arr[i][j];
}
System.out.println("销售额 " + sum);
}
System.out.println("总销售: " + sum);
}
}