Java学习第七天

一：数组
 1:概念： 相同或者是相兼容的数据类型的数据的集合。
          这些数据在占据一组连续的内存单元。 
  内存单元当中存放的数据称之为：元素。
  每一个元素都有一个下标索引。 下标索引是从0开始，最大索引是数据长度-1.
 2：数据的定义: 
    定义方式一：声明数组时，同时初始化。
    语法： 数据类型 [] 数组的名称 ={value1,vlaue2,value3};
    定义方式二： 先开辟空间。后赋值。
           数据类型 [] 数组的名称=new 数据类型[ int length];
    案例： new int[5]
    在堆内存当中开辟了一个空间，空间的长度为5. 存放的数据类型为int或者是和int相兼容的类型。
    开辟了空间 ，没有赋初始值，会采用默认值。（整型——0 浮点型——0.0 char——   String——null）
3：元素的访问： 
   （1）访问数组当中的某个元素，使用数组的下标索引来访问。
         语法： 数组的名称[index];
   （2）访问数组当中所用的元素： 
      属性： length;  可以获得元素的长度。
      可以使用for循环 ：循环得到数组当中所有的元素。  

 4:求数组元素当中的最大值：(两种方式) //求数组元素当中的最大值
public static int getMax(int [] arr) {
int max=arr[0];
for(int i=0;i<arr.length;i++) {
if(max<arr[i])
max=arr[i];
}
return max;
}
//求数组元素的最大值 利用下标索引
public static int getMax1(int [] arr) {
int max=0;
for(int i=1;i<arr.length;i++) {
if(arr[max]<arr[i])
max=i;
}
return arr[max];
}   求数组元素当中的最小值：(两种方式) //求数组元素当中的最小值
public static int getMin(int [] arr) {
int min=arr[0];
for(int i=0;i<arr.length;i++) {
if(min>arr[i])
min=arr[i];
}
return min;
}
//求数组元素的最大值 利用下标索引
public static int getMin1(int [] arr) {
int min=0;
for(int i=1;i<arr.length;i++) {
if(arr[min]>arr[i])
min=i;
}
return arr[min];
}   指定位置的元素替换： //指定位置的元素替换
public static void transData(int [] arr,int pos1,int pos2) {
int temp=arr[pos1];
arr[pos1]=arr[pos2];
arr[pos2]=temp;
// System.out.println(Arrays.toString(arr));
}   数组的反转 //数组的反转
public static void reverse(int [] arr) {
for(int i=0;i<arr.length/2;i++) {
// int temp=arr[i];
// arr[i]=arr[arr.length-1-i];
// arr[arr.length-1-i]=temp;
transData(arr,i,arr.length-1-i);
}
System.out.println(Arrays.toString(arr));
}
//数组的反转2
public static void reverse2(int [] arr) {
for(int start=0,end=arr.length-1;start>end;start++,end--) {
// int temp=arr[start];
// arr[start]=arr[end];
// arr[end]=temp;
transData(arr,start,end);
}
System.out.println(Arrays.toString(arr));
}   数组的copy //数组的拷贝
int [] arr1=new int[8];
System.arrayc
4000
opy(arr, 1,arr1 , 2, 3);
System.out.println(Arrays.toString(arr1)); 5：数组的copy。 
    int arr[]={1,2,3,4,5,6};
    int arr1={};
    System类
    arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
          从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
    参数一：src： 源数组
    参数二：srcPos：源数组的起始位置。
    参数三：desc ：目标数组
    参数四：destPos：目标数组的起始位置
    参数五：指定源数组的长度。

 6:和数组相关的异常。
    ArrayIndexOutofBoundsException 数组越界异常。
    NegativeArraySizeException 分配了数组的负长度异常。
    NullPointException 空指针异常。 null调用任何的方法或者是属性，都会触发该异常。
  7: 数据类型 [] 数组的名称
  [] 可以放在数据类型的后边，也可以放在数组名称的后边， 当只定义一个一维数组，存放的位置
   没有任何的影响。建议放在数据类型的后边。
  [] 放在数据类型后边，表示每个变量共享。
  [] 放在变量名称的后边，表示变量特有。
   int [] a,b; // 表示声明两个一维数组。
   int a[] , b; //定义定义一个一位数组，和一个int类型的变量b。
   int a[],b[];
 8:数组之间的相互赋值：
   (1)栈内存： 方法中基本数据类型和引用类型的变量，都放在栈内存当中。
      特点： FILO（First in Last out） 案例： 子弹夹
  (2)堆内存： 通过new 关键字申请的空间，都存放在堆空间当中。
             堆是对立与栈空间之外的一块内存区域。   
   复合数据类型：
   类： 
   数组
   接口：
 二： 二维数组
  1：如果一个数组的元素还是一个数组，那么这个数组称之为二维数组。  
     int arr[]={2,1,2,3};
     int arr[][]={{1,2,3},{2,1},{4,5,6,7,8}};
  2:定义：
     定义方式一：
     数据类型 [][] 数组的名称={{value1,valu2...},{value1,value2..},{},{}....}
     定义方式二：
     数据类型[][] 数组的名称=new 数据类型[length][];  锯齿型数组
       数据类型[][] 数组的名称=new 数据类型[length][length]; 规则的二维数组
  3:二维数组的访问：
    数组的名称[] ; 得到是二维数组当中的第几个元素。
    数组的名称[][] ; 得到的是第几个元素 当中的第几个元素。
    遍历：二维数组当中的所有的元素：
  4：二维数组的应用：
     （1）和数学当中的矩阵结构结构 
           1     2      3
   2     4      5
   4     3      8  
     （2）从地图上获得精确位置：  
     （3）显示生活当中的实际应用：
     某公司 某部门的每季度的销售总额。
    { {4,4,6}, {5,3,2} ,{5,7,9},{1,2,3} }       //某公司 某部门的每季度的销售总额
int [][]arr3= {{4,4,6},{5,3,2},{5,7,9},{1,2,3}};
for(int i=0;i<arr3.length;i++) {
int sum=0;
for(int j=0;j<arr3[i].length;j++) {
sum=sum+arr3[i][j];
}
System.out.println("第"+(i+1)+"季度的销售总额："+sum);
}  5：面试问题：
    打印杨辉三角：
    1 
    1 1
    1 2  1 
    1 3  3  1 
    1 4  6  4  1
    1 5  10 10 5  1 //打印杨辉三角形
int [][]arr4=new int[6][];
arr4[0]=new int[1];
arr4[0][0]=1;
for(int i=1;i<=5;i++) {
arr4[i]=new int[i+1];
arr4[i][0]=1;
arr4[i][i]=1;
for(int j=1;j<i;j++) {
arr4[i][j]=arr4[i-1][j-1]+arr4[i-1][j];
}
}
for(int i=0;i<arr4.length;i++) {
for(int j=0;j<arr4[i].length;j++) {
System.out.print(arr4[i][j]+" ");
}
System.out.println();
}
三：进制之间的准换：
 二进制： 0  1     逢二进一
 八进制： 
 十进制：
 十六进制： 组成0-9 A-F （a-f）
 二进制和十进制之间的转换：
十进制---->二进制：(短除2，余数倒取)
9  ---->1001
         二进制----> 十进制
         1001---> 9  : 1*2^0+1*2^3=9  系数*位权
 二进制和八进制之间的转换： 八进制数字以o开头；
       八进制----> 二进制（一位对三位）
        o765 ----> 111 110 101
二进制---->八进制（三位对应一位）
        001 001 101 010 101 -----> o11525
 二进制和十六进制之间的准换：十六进制的数都是ox 开头
      十六进制----->二进制（一位对应四位）
       ox128f -----> 1 0010 1000 1111
      二进制------>十六进制：（四位对应一位，不够四位前边补0）       
       0001 0011 0101 0101  ox1355
      十进制----十六进制
       258  ----> ox102
      十六进制--->十进制：
      ox102-----> 系数乘以位权  2*16^0+1*16^2 =258