---------------------- <a href="http://edu.csdn.net/heima"target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------
最近真是心力交瘁，乱想一通。发到文学社的稿子被采用是唯一值得偷笑一会的事，剩下的，都是闹心事。真是急于求成了，越弄越乱，真是讨厌反作用啊。是时候好好调节自己了。
还有一个最大的体会。看了视频不多操作真是不行！
第四天学的是引用数据类型之一的数组。数组的格式有这么几种：
一：元素类型[ ]数组名=new元素类型（元素个数或数组长度）
二：元素类型[ ]数组名=new元素类型[ ] {元素、、、、、、、}
三：元素类型[ ]数组名={元素。、、、、、、、}
Java运行时分配空间为栈和堆等5个，其中栈中数据使用完毕会自动释放（java虚拟机在适当的时候会自动取用垃圾回收机），堆中包含的是分装数据的实体，里面的数据初始化值默认为空null。
该记得的错误提示：
1， ArrayIndex out Bound Exception这是操作数组时，访问到了数组中不存在的角标。
2， Null Pointer Exception空指针异常，指向值为null的情况。
简单获取数组中某元素的方法：
class Noname
{
public static void main(String[] args)
{
int [] arr=new int [3];
System.out.println ("arr["+0+"]="+arr[0]+";");
}
}
要注意的是数组中有一个属性可以直接获取到数组元素的个数:length，方便遍历。
遍历能获取数组中的所有元素，如：
class Noname
{
public static void main(String[] args)
{
int []arr={2,3,4,5,6,6,5,};
shuzu(arr);
}
public static void shuzu(int [ ]arr)
{
for (int x=0;x<arr.length ;x++ )
{
if (x!=arr.length-1)
System.out.print( arr[x]+", ");
else
System.out.println (arr[x]);
}
}
}
遍历应用很多，如，定义一个获取数组中最大值：
public class Noname10
{
public static void main(String[] args)
{
int [] arr={1,2,3,4,4,76,354,34};
int max=zuida(arr);
System.out.println("max="+max);
}
public static int zuida(int []arr)
{
int max=arr[0];//局部变量，生存周期：定义它的函数
for (int x=1;x<arr.length ;x++ )
{
if (arr[x]>max)
max=arr[x];
}
return max;
}
}
此段代码中我出错很多次，首先是没有定义，没搞明白局部和全局变量的应用。函数里定义的是局部的，读完函数就无效了，若要要用，则要重新再定义一次。这比较麻烦，快捷的一个办法如下：
public class Noname10
{
static int max;//全局变量成员变量
public static void main(String[] args)
{
int [] arr={1,2,3,4,4,76,354,34};
zuida(arr);
System.out.println("max="+max);
}
public static int zuida(int []arr)
{
max=arr[0]; for (int x=1;x<arr.length ;x++ )
{
if (arr[x]>max)
max=arr[x];
}
return max;
}
}
在开始时定义一个static，定义的变量可以全局使用，之后不必再定义，之后出现的所有这个变量都得保持同一含义，不可混乱使用。
在此函数中还需注意的一个问题是，如果想把初始化值改为0，方便记忆和看的话，该如何改动呢？
其实只要把第一个max定义为o，然后if中的判断改为 arr[x]>arr[max]；还有把return中返回值的改为arr[max]即可，代码如下：
public class Noname10
{
public static void main(String[] args)
{
int [] arr={1,2,3,4,4,76,354,34};
int max=zuida(arr);
System.out.println("max="+max);
}
public static int zuida(int []arr)
{
int max=0;
for (int x=0;x<arr.length ;x++ )
{
if (arr[x]>arr[max])
max=x;
}
return arr[max];
}
}
接下来是排序的问题。选择排序是两函数作用的：遍历和排序。选择排序中内循环环绕一次，最值出现在头角标位置上。代码如下：
class Noname
{
public static void main(String[] args)
{
int []arr={2,4,23,5,6,5,1,};
shuzu(arr);
//System.out.printfln(arr)这是错的，如此就打印数组的地址了
bijiao(arr);
shuzu(arr);
}
public static void shuzu(int [ ]arr)
{
for (int x=0;x<arr.length ;x++ )
{
if (x!=arr.length-1)
System.out.print( arr[x]+", ");
else
System.out.println (arr[x]);
}
}
public static void bijiao(int [ ]arr)
{
for (int x=0;x<arr.length-1 ; x++)//减1是为了少一次比较
{
for (int y=x+1;y<arr.length ;y++ )//加1是为了前后对比
{
if(arr[x]>arr[y])
{
int temp=arr[x];
arr[x]=arr[y];//基本换位
arr[y]=temp;
}
}
}
}
}
排序的另外一种方法是冒泡排序。它的原理是相邻的两个元素比较，如果符合条件就换位，否则不换，它的最大值第一圈出现在最后面。
举同样的例子，冒泡排序和选择排序一样需要遍历。
public static void shuzu(int [ ]arr)
{
for (int x=0;x<arr.length ;x++ )
{
if (x!=arr.length-1)
System.out.print( arr[x]+", ");
else
System.out.println (arr[x]);
}
}
public static void bijiao(int [ ]arr)
{
for (int x=0;x<arr.length-1 ; x++) //减1加1结果不变，只是少了一次比较而已
{
for (int y=0;y<arr.length-x-1 ;y++ )
{
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
}
可发现它和选择排序有下面几个不同：
1，冒泡排序都是都是从0开始的，所以函数bijiao中y的初始化值改为0
2，条件中除了减1外，还要减x，减1是为了避免角标越界，减x是为了让每次比较的元素少1
3，而if中的条件由x,y变成y,y+1.如果满足条件也一样互换：
If (arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
Java中有一种已定义好的一种最简单的真正开发用于排序的函数：
Arrays.sort(arr);
接下来是查找功能的学习。
也是用函数包装。如下：
class Noname
{
static int x;//注意：全局定义的x不能与局部定义的意思相冲突
public static void main(String[] args)
{
int []arr={2,4,23,5,6,5,1};
x=chazhao(arr,4);//函数中返回值的x返回给chazhao,然后赋值给x,再输出。
System.out.println(x);
}
public static int chazhao(int [ ]arr,int key)
{
for (int i=0;i<arr.length ;i++ )
{
if (arr[i]==key)
return i;
}
return -1;
}
}
为了加快效率，可用一半一半排除的查找法，但它的条件必须是有序的数组。
/*关于折半查找的两种方法，
查到输出位置，没这个数，输出-1，注意变量的定义。
一
class Noname
{
public static void main(String[] args)
{
int []arr={1,3,4,5,12,34,56,78,99};
int i=halfsearch(arr,99);
System.out.println("mid="+i);
}
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;
}
}
二
class Noname
{
public static void main(String[] args)
{
int []arr={1,23,3,4,5,66,778,8};
int i=halfsearch(arr,5);
System.out.println("mid="+i);
}
public static int halfsearch (int [ ]arr,int key)
{
int min=0,max=arr.length-1,mid;
while (min<=max)
{
mid=(max+min)/2;
if (key>arr[mid])
min=mid+1;
else if (key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
而想要把一个元素插入到该有序数组中，也是通过折半的方法，先查是否有同样的数，是的话，直接插入，不是的话，返回最小指标的值插入。
上面几段排序代码可以看出共性，比如都得比较，都得换位，其实换位功能可以用函数包装起来，方便复用。
public static void huangwei (int [ ]arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
那么，如何用代码进行进制转换呢？
首先，举个例子，十进制转二进制。
/*十进制转换为二进制*/class Noname
{
static int num;
public static void main(String[] args)
{
toBin(60);
}
public static void toBin(int num)
{
/*while (num>0)
{
System.out.println(num%2);
num=num/2;
}
}*/
StringBuffer sb = new StringBuffer();//一储存的容器
while (num>0)
{
sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse( ));//反转功能
}
}
而十进制转为十六进制的代码有所不同：
/*十进制转换为十六进制*/class Noname
{
public static void main(String[] args)
{
toshiliu(60);
}
public static void toshiliu(int num)
{
StringBuffer sb = new StringBuffer();//一储存的容器
for (int x=0;x<8 ;x++ )// 用循环的原因：int n1=num&15;
// n1-10+'a'
// int temp=num>>>4
// temp&15;
{
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+‘A’较难理解和记，什么情况下可以不用到却能转换呢？这里就引用了查表法。可通过数据的形式来定义。
将上段代码改为查表法则为：
/*十进制转换为十六进制，用查表法优化 */class Noname
{
public static void main(String[] args)
{
toshiliu(60);
}
public static void toshiliu(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];//定义临时容器，8为最大
StringBuffer sb = new StringBuffer();//一储存的容器
for (int x=0;x<8 ;x++ ) // 用循环的原因：int n1=num&15;
// n1-10+'a'
// int temp=num>>>4
// temp&15;
{
int temp=num&15;
arr[ x]=chs [temp];
num=num>>>4;
}
for (int x=arr.length-1;x>=0 ;x-- )//length得减1，不然越界
{
System.out.println(arr[x] +“，”);//不可把单引改成双引号，输出结果会不正确，输出的是原本结果加上字符的结果。我就是犯了这错，找了很久
}
}
}
其实还可以更优化，下面两段代码时逐层优化十进制转十六进制的
/*20中十进制转换为二进制的优化*/
class Noname
{
public static void main(String[] args)
{
toshiliu(60);
}
public static void toshiliu(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];//定义临时容器，8为最大
int pos=0;
while (num!=0)
{
int temp=num&15;
arr[pos++]=chs [temp];
num=num>>>4;
}
for (int x=pos-1;x>=0 ;x-- )
{
System.out.println(arr[x]);
}
}
}//数组里面存数据可引用指针
class Noname21
{
public static void main(String[] args)
{
toshiliu(16);
}
public static void toshiliu(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];//定义临时容器，8为最大
int pos=arr.length-1;
while (num!=0)
{
int temp= num&15;
arr[pos--]=chs [temp];
System.out.println(temp+" arr[]="+arr[pos+1] +";post="+(pos+1) );
num=num>>>4;
}
for (int x=pos+1;x<arr.length ;x++ )
{
System.out.println(arr[x]);
}
}
}
刚刚得到一个很奔溃的消息，今天花一天时间弄明白的进制转换运用时一般都直接调用快捷函数。那些方法没什么必要，因为较麻烦，所以奔溃的我不把那些十进制转二进制查找法优化代码写在这儿了。
王道代码是：
十进制转换为十六进制public class Test2
{
public static void main(String[] args)
{
int a=20;
System.out.println(Integer.toBinaryString(a));//2进制
System.out.println(Integer.toHexString(a));//16进制
System.out.println(Integer.toOctalString(a));//8进制
}
}
自己写的心得和笔记要时常翻阅，一些细节问题要记在心里。敲代码不是浮云，记得。
---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
