01 数组静态初始化
定义格式1
int[] arr= new int[5];
定义格式2 ， 赋值啦
int[] arr = new int[] {3,5,7,9}; //静态初始化方式
记住别写长度～
arr[0]- arr[length-1] 有效值
数组中两种常见的异常：
1.下角标越界
2.空指针异常
02 数组(常见操作-遍历)
怎么操作数组， 获取数组的元素。
通常会用到遍历
PS：在做练习的时候，时刻提醒自己将以前的知识一起使用，比如要有函数，要有函数的重载，等等。
不要单独的做练习。
for (int i ; i<数组名.length; i++)
求和： 变量+ 循环
public static void addArray (int[] arr)
{
int sum=0;
for (int i=0;i<arr.length ;i++ )
{
//System.out.println("Array["+i+"]="+num[i]);
sum +=arr[i];
}
System.out.println("数组的和是"+sum);
有时候要区分是不是最后一个元素，
需要用x!=arr.length-1 判断下
public static void printArray (int[] arr)
{
for (int i=0;i<arr.length ;i++ )
{
if (i!=arr.length-1)
{
System.out.print(arr[i]+", ");
}
else
System.out.print(arr[i]);
}
}
03 数组练习
给定一个数组 ： {8,2,12,4,5,0}
1，获取最大值 最小值
public static int getAmax (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 getAmin (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 void main(String[] args)
{
int[] arr1 = new int[] {-1,3,6,8,-21};
double[] arr2 = new double[] {2.1,2.3,7.7,9.8};
//getAE(arr1);
//getAE(arr2);
//addArray(arr1);
printArray(arr1);
int max =getAmax(arr1);
int min =getAmin(arr1);
System.out.println("Max="+max);
System.out.println("Min="+min);
}
}
另外一种思路是用角标：
max=0,
if(arr[x]>arr[max])
max=x;
returnarr[max];
04 05 数组排序
排序的思路：
1.选择排序
将数组的第一个元素和后面的每个比较，不断交换，保证第一个元素是整个数组中最小的
将数组的第二个元素和后面的每个比较，。。。。。。。第二个。。。。。。。。。。。
....
将数组的倒数第二个元素和后面的每个比较.............
a[0] 和 a[1]- a[length-1]
a[1]和 a[2]-a[length-1]
....
a[length-2]和a[length-1]
将a[i=0] 和 a[j=i+1] - a[length-1]
a[i=1]和 。。。。。。。。
a[i=lenght-2]和............
当然也可以用这样的方式交换
if(arr[x]> arr[y])
{
int temp = arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
2. 冒泡排序
思路：
1 ，相邻的比较，最大值出现在 arr[length-1]
2 ， 相邻的比较 ，最大值出现在arr[lentgh-2]
...
最后 ， ..... 最大值出现在 arr[1]，
所以外循环i=arr.length-1, i>0 , i--
内循环 j=0; j <i ; j++
比较 并交换 ： arr[j] , arr[j+1]
=====
快速排序
import java.util.*; 就可以玩排序了
importjava.util.Arrays
int[] a =new int[]{2,3,1,9,20};
Arrays.sort(a); //快速排序
for (inti:a)
{System.out.print(i);}
=======
把堆内存频繁的换位置，转换成，在栈内存中换位置。
总结 ：外循环条件一致， 内循环 选择是关联初值， 冒泡是关联条件
选择排序
for (intx=0; x<arr.length-1;x++)
for (int y=x+1; y <arr.length;y++)
arr[x] arr[y]
冒泡
for (intx=0; x<arr.length-1,x++)
for(y=0; y<arr.length-x-1;y++)
arr[y] arr[y+1]
06 位置置换功能
发现所有的排序都要将元素交换位置， 所以可以把位置交换封装成一个功能。
07 元素查找
return -1 ,表示没有查找到
折半查找： 要先排序
思路，记录头角标和尾角标， 中间角标随之变化
key和数组中间的角标对应元素不相等需要继续折半，
public static inthalfFind2(int[] arr, int key){
intmin=0,max=arr.length-1,mid;
while(min<=max)
{
mid=(min+max)>>1;
if(key>arr[mid])
{
min=mid+1;
}
elseif (key<arr[mid])
{
max=mid-1;
}
elsereturn mid;
}
return -1;
}
将一个数插入到一个有序数组，使该数组依然有序， 求位置
008 进制转换
十进制 转二进制
需要一个容器来存储取余数的值，
学了一个新的容器叫StringBuffer ， 其中有两个方法， 一个是.append: 将数据存入，
一个是.reverse() : 将其中的数据反转
class DemoArray4
{
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());
}
public static void main(String[] args)
{
toBin(6);
}
}
十进制 - 转16进制
&15取 最低4位 ，然后将原来的数>>>4再 &15 ， 去次低4位，类推
依然用到StringBuffer.
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());
}
public static void main(String[] args)
{
//toBin(6);
toHex(60);
}
010 查表法 十进制 转 16
思路： 1. 不想用 temp-10+'a'
而是定义一张表， 从0-F， 将num&15 每次与后的值（如12）， 作为数据表的角标。
2.只要num不等于0，就可以继续移动，即得到的都是有效位。
3.用pos参数作为指针，arr[pos],将指针或加或减来实现对数组的操作。
4.将pos逆向存，正向用， 注意 pos--和--pos的区别
012 进制转换优化 ， 共性抽取。
进制转换的共性 ：
1. 需要一个表，新的Char型数组 ， 供与后的temp作为角标调用
2. 定义 arr数组作为存储容器
3.定义pos 指针来操作arr
4.While 循环 ， 只要num不为0就可以跑，确保有效位
5. 在循环内 查表并存储， 即 arr[pos]=ch[temp]
定义一个tran的函数， tran(num,base , offset)
先判断，如果num是0 ，返回0并 直接结束函数，下面的就不跑了，以免浪费内存
class DemoArray5
{
public static void tran(int num , int base , int offset)
{
char[] ch= new char[]{'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]=ch[temp];
num= num >>>offset;
}
for (int x=pos;x<arr.length ;x++ )
{
System.out.print(arr[x]);
}
}
public static void toBin (int num)
{
tran(num,1,1);
System.out.println("");
}
public static void toBa (int num)
{
tran(num,7,3);
System.out.println("");
}
public static void toHex (int num)
{
tran(num,15,4);
System.out.println("");
}
public static void main(String[] args)
{
toBin(6);
toBa(60);
toHex(60);
}
}
013 二维数组
把数组做为元素存放在一个数组中，即二维数组
定义 ： int[][] arr= new int [3][4];
定义了名称为arr的二维数组， 其中有3个一维数组 ， 每一个一位数组中有4个元素
SOP(arr) 返回二维数组的 地址
SOP(arr[0]) 返回其中第一个一维数组的地址
必须要定义 第一个[]的值
int[][] arr= new int [3][0];
SOP(arr[0]) 结果是Null
需要对每一个小数组进行手动的初始化
log： 不能用 int[][] arr=new int[3][]{{3,5,1,7},{2,3,5,8},{1,6,8,2}};
而是 int[][] arr={{3,5,1,7},{2,3,5,8},{1,6,8,2}};
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
