黑馬程序員.bobo.DAY.4

Day-4

1.數組(靜態初始化,常見問題)

2.數組(常見操做-遍歷)

 

class ArrayDemo3
{
<span style="white-space:pre">	</span>public static void main(String[] arg)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">	</span>//數組的操做:
<span style="white-space:pre">	</span>//獲取數組中的元素.一般會用到遍歷.
<span style="white-space:pre">	</span>//
<span style="white-space:pre">	</span>//int [] arr = new int[3];
<span style="white-space:pre">	</span>int [] arr = {3,6,5,1,8,9,68};
<span style="white-space:pre">	</span>//數組中有一個屬性能夠直接獲取到數組元素個數,length.
<span style="white-space:pre">	</span>//使用方式:數組名稱.length = 
<span style="white-space:pre">	</span>//System.out.println("length:"+arr.length);
<span style="white-space:pre">	</span>//int sum = 0;
<span style="white-space:pre">	</span>/*
<span style="white-space:pre">	</span>for(int x=0; x<arr.length; x++)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">	</span>//sum += arr[x];
<span style="white-space:pre">	</span>System.out.println("arr["+x+"]="+arr[x]+";");//arr[0]=0;
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>*/
<span style="white-space:pre">	</span>System.out.println(arr);
<span style="white-space:pre">	</span>printArray(arr);
<span style="white-space:pre">	</span>//printArray(arr);
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>//定義功能,用於打印數組中的元素,元素間用逗號隔開.
<span style="white-space:pre">	</span>public static void printArray(int[] arr)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>System.out.print("[");
<span style="white-space:pre">	</span>for(int x =0; x<arr.length; x++)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>if(x!=arr.length-1)
<span style="white-space:pre">		</span>System.out.print(arr[x]+",");
<span style="white-space:pre">		</span>else
<span style="white-space:pre">		</span>System.out.println(arr[x]+"]");
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}
}

 

3.數組(常見操做-獲取最值)

/*
給定一個數組{5,1,6,4,2,8,9}.
1,獲取數組中的最大值,以及最小值.
*/
class ArrayTest
{
/*
獲取數組中的最大值
思路:
1,獲取最值須要進行比較.每一次比較都會有一個較大的值,由於該值不肯定
經過一個變量進行臨時存儲.
2,讓數組中的每個元素都和這個變量中的值進行比較
若是大於了變量中的值,就用該該變量記錄較大值.
3,當全部的元素都比較完成,那麼該變量中存儲的就是數組中的最大值了
步驟:
1,定義變量,初始化爲數組中的任意一個元素接口
2,經過循環語句對數組進行遍歷
3,在遍歷過程當中定義判斷條件,若是遍歷到的元素比變量中的元素大,就賦值給該變量
須要定義一個功能來完成,以便提升複用性.
1,明確結果,數組中的最大元素 int.
2,未知內容:一個數組,int[]
*/
public static int getMax(int [] arr)
{
int max = arr[0];
for(int x =1; x<arr.length;x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}
/*
獲取最大值的另外一種方式.
能夠不能夠將臨時變量初始化爲0呢?
能夠,這種方式,實際上是在初始化爲數組中的角標
*/
public static int getMax_2(int [] arr)
{
int max = 0;
for(int x =1; x<arr.length;x++)
{
if(arr[x]>arr[max])
max = x;///角標值
}
return arr[max];//數組中最大元素的角標
}
//獲取最小值.
public static int getMin(int[] arr)
{
int min =0;
for(int x=0;x<arr.length;x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
//獲取double類型數組的最大值,由於功能一致,因此定義相同函數名稱,以重載形式存在
//public static double getMax(double[] arr)
public static void main(String[] args)
{
int[] arr ={5,1,6,4,2,8,9};
int max = getMax_2(arr);
int min = getMin(arr);
System.out.println("max="+max);
System.out.println("min="+min);
//boolean[] ar =new boolean[3];
//System.out.println(ar[0]);
}
}

 

4.數組(排序-選擇排序)

選擇排序

 

0 1 2 3 4 5 角標

3 1 4 2 7 5

 

3和1 若是3比1大 把小的(1)往前放

1 3 4 2 7 5

1和4 若是4比1大 把小的(1)往前放

 

/*
對給定數組進行排序
{5,1,6,4,2,8,9}
*/
class ArrayTest2
{
/*
選擇排序
內循環結束一次,最值出現頭角標位置上
*/
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1;x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
//在排序前打印;
printArray(arr);
//排序
selectSort(arr);
//在排序後打印
printArray(arr);
}
public  static  void  printArray(int[] arr)
{
System.out.print("[");
for(int x= 0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}

5.數組(冒泡排序)

 

import java.util.*;

 

/*
對給定數組進行排序
{5,1,6,4,2,8,9}
*/
class ArrayTest2
{
/*
選擇排序
內循環結束一次,最值出現頭角標位置上
*/
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1;x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
/*
冒泡排序
*/
public static void bubbleSort(int [] arr)
{
for(int x=0; x<arr.length-1;x++)//for(int x=arr.length-1;x>0;x++)
{//for(int y=0; y<x;y++)
for(int y=0; y<arr.length-x-1;y++)//-x:讓每一次比較的元素減小,-1,避免角標越界
{
if(arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
//在排序前打印;
printArray(arr);
//排序
//selectSort(arr);
//bubbleSort(arr);
Arrays.sort(arr);//Java調用
//在排序後打印
printArray(arr);
}
public  static  void  printArray(int[] arr)
{
System.out.print("[");
for(int x= 0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}

6.數組(排序-位置置換功能抽取)

7.數組(折半查詢)

 

 

/*
數組的查找操做
練習:有一個有序的數組,想要將一個元素插入到該數組中,還要保證該數組是有序的
*/
class ArrayTest4
{
public static void main(String[] args)
{
//int[] arr = {3,1,5,4,2,9};
//int index =getIndex(arr,2);
//System.out.println("index="+index);
int[] arr = {1,3,5,14,21,39};
int index = getIndex_2(arr,8);
System.out.println("index="+index);
}
public static int getIndex_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid;
while (min <= max)
{
mid = (max+min)>>1;//5>>1 5/2
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return min;
}
/*
折半的第二種方式.
*/
public static int halfSearch_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid;
while (min <= max)
{
mid = (max+min)>>1;//5>>1 5/2
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
/*
折半查找,提升效率,可是必需要保證該書組是有序的數組
*/
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid +1;
else if(key <arr[mid])
max = mid -1;
if(min >max)
return -1;
mid =  (max+min)/2;
}
return mid;
}
//定義功能,獲取key第一次出如今數組中的位置,若是返回是-1,那麼表明該key在數組中不存在.
public static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==key)
 return x;
}
return -1;
}
}

 

8.數組(十進制-二進制)

 

class ArrayTest5
 
{
public static void main(String[] args)
{
toBin(6);
}
/*
十進制→二進制
*/
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer();
while(num>0)
{
sb.append(num%2);
num = num /2;
}
System.out.println(sb.reverse());
}
}

 

9.數組(十進制-十六進制)

十進制60轉十六進制

 

 0000-0000 0000-0000 0000-0000 0011-1100 60

&0000-0000 0000-0000 0000-0000 0000-1111 15

-----------------------------------------------------------

                                00-1100 =12 →c

    0000-0000 0000-0000 0000-0000 0011 >>>

&0000-0000 0000-0000 0000-0000 0000-1111 15

---------------------------------------------------------------

                                  0011 = 3

60→3C

public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for(int x = 0; x<8; x++)
{
int temp = num & 15;
if(temp>9)
sb.append((char)(temp-10+'A'));
else
sb.append(temp);
num = num >>>4;
}
System.out.println(sb.reverse());
}

10.數組(查表法-十進制 十六進制)

 

 

class ArrayTest6
 
{
public static void main(String[] args)
{
toHex(60);
}
/*
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	11	12	13	14	15	16
查表法:將全部的元素臨時存數起來,簡歷對應關係.
每一次&15後的值做爲索引去查創建好的表,就能夠找對應的元素.
這樣比-10+'a'簡單的多.
這個表怎麼創建呢?
能夠經過數據的形式來定義.
發現終於出結果了.可是是反着的,想要正過來呢?能夠經過StringBuffer reverser功能來完成,可是這個工具尚未學習
因此可使用已經學習過的容器:數組來完成存儲
*/
public static void toHex(int num)
{
char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
//定義一個臨時容器.
char[] arr = new char[8];
int pos = arr.length;
while(num!=0)
{
int temp = num & 15;
//System.out.println(chs[temp]);
arr[--pos] = chs[temp]; 
num = num >>> 4;
}
//存儲數據的arr數組遍歷.
System.out.println("pos="+pos);
//存儲數據的arr數組遍歷.
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]+",");
}
}
 
}

 

11.數組(查表法,十進制,二進制)

public static void main(String[] args)
{
//toHex(60);
toBin(6);
}
public static void toBin(int num)
{
//定義二進制的表
char[] chs = {'0','1',};
//定義一個臨時存儲容器.
char[] arr = new char [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.println(pos+"---"+arr.length);
System.out.print(arr[x]);
}
}

12.數組(進制轉換優化)

 

 

class ArrayTest7
 
{
public static void main(String[] args)
{
toBin(6);
toBa(60);
toHex(60);
}
/*
十進制→二進制
*/
public static void toBin(int num)
{
trans(num,1,1);
}
/*
十進制→八進制
*/
public static void toBa(int num)
{
trans(num,7,3);
}
/*
十進制→十六進制
*/
public static void toHex(int num)
{
trans(num,15,4);
}
public static void trans(int num,int base,int offset)
{
if(num==0)
{
System.out.println(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]);
}
}
 
}

13.數組(二維數組)

 

 

class Array2Demo
 
{
public static void main(String[] args)
{
//int[][] arr = new int[3][4];//定義了名稱爲arr的二維數組,二維數組中有3個一堆數組
//每個一維數組中有4個元素
//System.out.println(arr[0][1]);
/*
int[][] arr = new int[3][];
arr[0] = new int [3];
arr[1] = new int [1];
arr[2] = new int [2];
System.out.println(arr.length);//打印二維數組的長度3;
System.out.println(arr[0].length);//打印二維數組中第一個一維數組長度
*/
int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int sum =0;
for(int x=0; x<arr.length;x++)
{
for(int y=0; y<arr[x].length;y++)
{
sum = sum +arr[x][y];
}
}
System.out.println("sum="+sum);
}
}

 

14.數組(二維數組練習)

/*
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;//yes
c.
y[0][0] = x;//error
d.
x[0][0] = y;//error
 
e.
y[0][0] = x[0];//yes
f.
x=y;//error
*/

添加好友

小額贊助

微信	支付寶