Java学习笔记四

51.
java中的数组是一个引用，所以也是可以调用equals方法的，如果比较两个数组的内容是否相同不能用equals方法；
比如int[]a={1,2,3,}
int[]b={1,2,3};
System.out.println(a.equals(b));
结果肯定是false；因为并没有实现对equals方法的重写，比较的是两个数组的引用地址；显然是不相同的
52．
构造方法的作用是对类中的属性赋初值，运用this方法，
返回给主函数
数组也是可以使用的
publicclassTest
{
publicstaticvoidmain(String[]args)
{
Person[]array=newPerson[3];//生成数组
array[0]=newPerson(12);//生成数组对象；并赋值给age
array[1]=newPerson(11);
array[2]=newPerson(23);
for(inti=0;i<array.length;i++)
System.out.println(array[i].age);
}
}
classPerson
{
intage;
publicPerson(intage)
{
this.age=age;

}
}
51、
奇数是张三偶数是李四
publicclassTest
{
publicstaticvoidmain(String[]args)
{
Person[]p=newPerson[100];

for(inti=0;i<p.length;i++)
p[i]=newPerson();
for(intj=0;j<=p.length;j++)
{
if(j%2==0)
p[j].name="zhangsan";
elsep[j].name="lisi";
System.out.println(p[j].name);

}
}
}
classPerson
{
Stringname;

}
用判断的方法来做
publicclassTest3
{
publicstaticvoidmain(String[]args)
{
Person[]a=newPerson[100];

for(inti=0;i<=a.length;i++)
{
a[i]=newPerson();
a[i].name=i%2==0?"lisi":"wangwu";
System.out.println(a[i].name);
}
}
}
classPerson
{
Stringname;

}
52.
数组是对象
53.？
如何验证数组是对象
int[]I=newint[10]
System.out.println(IinstanceofObject);
打印出true
54；
//关于二维数组的不规则形式
//二维数组允许先定义行再定义列的顺序，反过来是不可以的，因为先定义列就无法确认行数！
publicclassTest
{
publicstaticvoidmain(String[]args)
{
intm=3;
int[][]a=newint[3][];//先声明有三行；
a[0]=newint[3];//第一行有三个元素；
a[1]=newint[2];
a[2]=newint[1];
for(inti=0;i<a.length;i++)
{
for(intj=0;j<a[i].length;j++)
{
a[i][j]=m;
m+=2;
System.out.print(a[i][j]);
}
System.out.println("\n");

}

}
}//也可以这样写，在生成数组的时候就赋上值；int[][]a=newint[3][]{{1,23},{23},{7,8,7}}
55.
数组是对象，所以在生成数组时的变量就是一个引用，且引用指向数组的首地址等，即第一个；
int[]a=newint[3];
a是一个引用，既然a是一个引用那么当它进行传递时，就可以是其他的引用共同指向对象，即可以通过其他引用改变对象的内容；
publicclassTest
{
publicstaticvoidmethod(char[]ch,charch1)
{
ch[0]='C';//现在的ch也是一个引用，通过引用改变数组的第一个值；
ch1='D';

}
publicstaticvoidmain(String[]args)
{
char[]ch={'A','f'};
method(ch,ch[1]);//ch是一个数组引用，ch[1]是一个字符值；传给method方法；
System.out.println(ch[0]);
System.out.println(ch[1]);

}

}
打印结果、：
cf;
发现：如果直接打印数组的引用打印出来的是数组的所有元素；
因为java里面没有指针，所以只能通过数组的形式来交换方法的数值，传递给方法数组的引用后，就可以对数组进行修改，如同上例；
56．
要注意的是声明数组的时候并没有声称对象，只是生成了数组对象的实例，
我们知道接口interface，是不能生成对象的；
57.
关于静态static如果生命在本类当中的属性，则该类中的方法，可以直接调用，而不用前缀类名；如类为Test直接method（）；
58;
//比较两个数组是否相同，要比较数组的长度和内容是否相同；
/比较两个数组是否相同，要比较数组的长度和内容是否相同；
importjava.util.Arrays;
publicclassTest
{
publicstaticbooleanmethod(int[]x,int[]y)
{
if(x==null||y==null)
returnfalse;
if(x.length!=y.length)
returnfalse;
for(inti=0;i<x.length;i++)
{
if(x[i]!=y[i])
returnfalse;

}
returntrue;
}
publicstaticvoidmain(String[]args)
{
int[]a={3,4,6};
int[]b={3,4,5,6};
System.out.println(method(a,b));
System.out.println(Arrays.equals(a,b));
//不做这样做是有些麻烦，java中有专门的方法来比较两个数组是否相同，就是位于java.utill.Arrays类
//由于不是java.lang包下的类所以要声明导入；

}
}
59.
关于数组拷贝copy的问题。回过头来看下
60．
数组的功能：查询和排序
1.冒泡排序
publicclassTest
{
publicstaticvoidmethod(int[]a)
{
inttemp;
for(inti=0;i<a.length-1;i++)//这点是要非常注意的，上面是长度减一，下面是长度减一减i;!
for(intj=0;j<a.length-1-i;j++)
{

if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}

}
for(intx=0;x<=9;x++)
System.out.println(a[x]);

}
publicstaticvoidmain(String[]args)
{
int[]a={2,3,4,1,54,32,45,32,221,44};
Test.method(a);

}
}
61.
关于二分查找

关于二分查找我有两个问题，希望高手能指点一二。

1.二分查找的对象是个有序数组，如果这个数组元素个数为偶数时的情形是怎样的呢？这个我似乎在书上没有找到。比如如果查找的数组元素个数为12个，那么mid指针指向的是第几个元素呢？

2.对于任意长度的有序数组，二分查找真的能在最多4次查找之后就可以返回结果吗？为什么？

1

对于查找条件为等式的情况，mid指针可以指向中间偏左，也可以指向中间偏右，对于查找条件为不等式时，要根据具体情况选择，查找大于某数的第一个数值时选择指向中间偏左，查找小于某数的第一个数值时选择之下是那个中间偏右

2

这个说法是错误的，二分查找的复杂度为O(logn),简单的说，就是对于n个元素的数组，大约需要查找logn次，如n=1000，则需要7次查找

62.

//自己写的二分排序法，我自己的理解

//二分排序法得以进行的条件是数组必须是有序的；这里我选择升序；

//由于是折中进行，所以数组索引值会向中间靠拢，当找到所需值，或者找到索引的最小最大值相等时，循环就结束了

//对于奇数索引数组元素为偶数来说，因为length是整形，除以二当然舍弃小数点，这里偶数奇数数组都是没有影响的

//如果在左边索引最高值为中间值-1；在右边最小值为中间值+1

publicclassTest3

{

publicstaticintmethod(int[]a,intvalue)

{

intlow=0;

inthigh=a.length-1;

intmiddle;

while(low<=high)

{

middle=(low+high)/2;

if(value==a[middle])

returnmiddle;

if(value<a[middle])

high=middle-1;

if(value>a[middle])

low=middle+1;

}

return-1;

}

publicstaticvoidmain(String[]args)

{

int[]a={1,2,3,4,5,6,7,8};

intvalue=3;

System.out.println(method(a,value));

}

}

63.

时间复杂度：同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。
按数量级递增排列，常见的时间复杂度有：
　　常数阶O(1),对数阶O(log2n),线性阶O(n),

　　线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),...，
　　k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

64.

随机Random；

//如何随机生成数字；通过调用java.util包下的Random类的nextInt（int）方法来实现。其中n代表随机数的边界，但随机数不包含边界n;

//即生成的数字介于0<=x<n,之间，下面的程序是要找到10——50的随机数，所以加上了10；注意括号的位置；

importjava.util.Random;

publicclassRandomTest

{

publicstaticvoidmain(String[]args)

{

Randomr=newRandom();

for(inti=0;i<50;i++)

System.out.println(r.nextInt(41)+10);

}

}

看一下另一种方法

//随机生成数字，在java.lang包下也有一个类Math.random()方法，功能是返回一个double型随机数字

//方法原型为publicstaticdoublerandom();

//数字的范围介于0.0——1.0之间，当然左等右不等，例如上例，仍然要生成介于10-50间数字，而且是整数，则要涉及到几个步骤

//第一，将范围增加到目的。二是要强制类型转换

publicclassRandomTest

{

publicstaticvoidmain(String[]args)

{

for(inti=0;i<50;i++)

System.out.println(Math.random());

for(inti=0;i<50;i++)

{

doublea;//要注意定义a的类型；

a=Math.random();

a*=41;

inta2=(int)a;

a2+=10;

System.out.println(a2);

}

}

}

65.

来看一道题

随机生成50个数字（整数），每个数字的范围是[10,50]，统计每个数字出现的次数以及出现次数最多的数字与它的个数，最后将每个数字及其出现次数打印出来，如果某个数字出现次数为0，则不要打印它。打印时按照数字的升序排列。

importjava.util.Random;

publicclassTest

{

publicstaticvoidmain(String[]args)

{

Randomrandom=newRandom();

int[]count=newint[41];

for(inti=0;i<50;i++)

{

intnum=random.nextInt(41)+10;

System.out.println(num);

count[num-10]++;

}

for(intj=10;j<51;j++)

{

if(count[j-10]==0)//如果个数为零的话不打印；

continue;

System.out.print(j+"共有");

System.out.println(count[j-10]+"个");

}

}

}