JAVA第二次作业
（一）学习总结
1.学习使用Eclipse关联jdk源代码,查看String类的equals（）方法，截图，并学习其实现方法。举例说明equals方法和==的区别。
String类的equals方法是对String的内容进行比较，
是对数值进行比较，String中使用对地址值进行比较。
举例说明：
String str1 = “hello”;
String str2 = new String("hello");
String str3 = str2;
System.out.printli("str1 == str2 -->" + (str1 == str2)); false
System.out.printli("str1 == str3-->" + (str1 == str3)); false
System.out.printli("str2 == str3 -->" + (str2 == str3)); true
str1和str2的值不相等，所以false
str2和str3的地址值相等，所以true
ste1和str3地址值不相等，所以false
String str1 = “hello”;
String str2 = new String("hello”)；
String str3 = str2;
System.out.printli("str1 equal str2 -->" + (str1.equal(str2))); true
System.out.printli("str1 equal str3-->" + (str1.equal(str3))); true
System.out.printli("str2 equal str3 -->" + (str2.equal(str3))); true
str1,str2,str3的内容是一样的，都是hello，所以true
2.什么是构造方法？什么是构造方法的重载？下面的程序是否可以通过编译？为什么？
（1）构造方法是一种特殊的方法，它是一个与类同名且没有返回值类型的方法。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
在Java中,任何 变量在被使用前都必须先设置初值.Java提供了为类的 成员变量赋初值的专门方法。
（2）只要每个构造方法的参数类型或参数个数不同，即可实现重载
（3）不能编译，Foo()未定义
public class Test {
public static void main(String args[]) {
Foo obj = new Foo();
}
}
class Foo{
int value;
public Foo(int intValue){
value = intValue;
}
}
3.运行下列程序，结果是什么？查阅资料，分析为什么。
public class Test {
public static void main(String args[]) {
double a = 0.1;
double b = 0.1;
double c = 0.1;
if((a + b + c) == 0.3){
System.out.println("等于0.3");
}else {
System.out.println("不等于0.3");
}
}
结果是“不等于0.3”
import java.math.BigDecimal;
public class tes {
public static void main(String args[]) {
BigDecimal a1=new BigDecimal("0.1");
BigDecimal b1=new BigDecimal("0.1");
BigDecimal c1=new BigDecimal("0.1");
if( a1.add(b1).add(c1).doubleValue() == 0.3){
System.out.println("等于0.3");
}else {
System.out.println("不等于0.3");
}
}
}
4.运行下列程序，结果是什么？分析原因，应如何修改.
public class Test {
public static void main(String[] args) {
MyClass[] arr=new MyClass[3];
arr[1].value=100;
}
}
class MyClass{
public int value=1;
}
结果是“Exception in thread "main" java.lang.NullPointerExceptionat shiyany.shiyany.main(shiyany.java:6)”意思为线程主java.lang.nullpointerexception中的异常，异常的解释是＂程序遇上了空指针＂，简单地说就是调用了未经初始化的对象或者是不存在的对象，
5.在一个10000次的循环中，需要进行字符串的连接操作，那么，应该使用String类还是StringBuffer类，为什么？性能有差异吗？能否写出测试代码证明你的结论。（可查阅资料）
应该使用StringBuffer类，因为StringBuffer 的速度几乎是String上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候，差异更大。如果在程序中需要对字符串进行频繁的修改连接操作的话.使用StringBuffer性能会更高
有，string 是定长字符串；StringBuffer是不定长字符串；字符串连接操作中StringBuffer的效率要比String高:
String的内容是不可改变的，每次赋新值都会产生一个新的String句柄来指向新值，而StringBuffer的值是可以改变的。而且StringBuffer中有很多方法，使插入或替换字符（串）等操作变得更方便。
String 类代表字符串。String类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。
StringBuffer上的主要操作是apend和inser方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
将26个英文字母重复加了5000次，
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lstart1 = System.currentTimeMillis();
String str = "";
for (int i = 0; i < times; i++) {
str += tempstr;
}
long lend1 = System.currentTimeMillis();
long time = (lend1 - lstart1);
System.out.println(time);
得到的结果每次不一定，一般为 1563左右。
我们再看看以下代码
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lstart2 = System.currentTimeMillis();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < times; i++) {
sb.append(tempstr);
}
long lend2 = System.currentTimeMillis();
long time2 = (lend2 - lstart2);
System.out.println(time2);
得到的结果为 16 有时还是 0
所以结论很明显，StringBuffer 的速度几乎是String 上万倍。当然这个数据不是很准确。因为循环的次数在100000次的时候，差异更大。
6.其他需要总结的内容
java中四中数组排序方法
-
直接插入排序
-
基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序
public void insertSort(int[] array){
int temp=0;
for(int i=1;i<array.length;i++){
int j=i-1;
temp=array[i];
for(;j>=0&&temp<array[j];j--){
array[j+1]=array[j]; //将大于temp的值整体后移一个单位
}
array[j+1]=temp;
}
} -
冒泡排序
-
基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
public void bubbleSort(int[] array) { int temp; for(int i=0;i<array.length;i++){//趟数 for(int j=0;j<array.length-i-1;j++){//比较次数 if(array[j]>array[j+1]){ temp=array[j]; array[j]=array[j+1]; array[j+1]=temp; } } } } -
快速排序
-
基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
public void qsort(int array[]){ if(array.length>1){ _qsort(array,0,array.length-1); } } -
一趟快速排序
private void _qsort(int[] array,int low,int high){ if(low < high){ int middle = getMiddle(array, low, high); _qsort(array,low,middle-1); _qsort(array, middle+1, high); } } -
得到中间值
private int getMiddle(int[] array,int low,int high){ int tmp = array[low]; while(low < high){ while(low < high && array[high] >= tmp) high--; array[low] = array[high]; while(low<high && array[low]<=tmp) low++; array[high] = array[low]; } array[low] = tmp; return low; } -
简单选择排序
-
基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
public void selectSort(int[] array){ int position=0; for(int i=0;i<array.length;i++){ int j=i+1; position=i; int temp=array[i]; for(;j<array.length;j++){ if(array[j]<temp){ temp=array[j]; position=j; } } array[position]=array[i]; array[i]=temp; }}
-
希尔排序（最小增量排序）
-
基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。
public void shellSort(int[] array){ double d1=array.length; int temp=0; while(true){ d1= Math.ceil(d1/2); int d=(int) d1; for(int x=0;x<d;x++){ for(int i=x+d;i<array.length;i+=d){ int j=i-d; temp=array[i]; for(;j>=0&&temp<array[j];j-=d){ array[j+d]=array[j]; } array[j+d]=temp; }}
if(d==1)
break;
}
}
public void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
}
下面是几种排序方法分开使用的示例
利用Arrays带有的排序方法快速排序
代码如下:
import java.util.Arrays;
public class Test2{
public static void main(String[] args){
int[] a={5,4,2,4,9,1};
Arrays.sort(a); //进行排序
for(int i: a){
System.out.print(i);
}
}
}
冒泡排序算法
代码如下:
public static int[] bubbleSort(int[] args){//冒泡排序算法
for(int i=0;i<args.length-1;i++){
for(int j=i+1;j<args.length;j++){
if (args[i]>args[j]){
int temp=args[i];
args[i]=args[j];
args[j]=temp;
}
}
}
return args;
}
选择排序算法
代码如下:
public static int[] selectSort(int[] args){//选择排序算法
for (int i=0;i<args.length-1 ;i++ ){
int min=i;
for (int j=i+1;j<args.length ;j++ ){
if (args[min]>args[j]){
min=j;
}
}
if (min!=i){
int temp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
return args;
}
插入排序算法
代码如下:
public static int[] insertSort(int[] args){//插入排序算法
for(int i=1;i<args.length;i++){
for(int j=i;j>0;j--){
if (args[j]<args[j-1]){
int temp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}else break;
}
}
return args;
}
（二）实验总结
实验一：
程序设计思路：利用冒泡排序求最大值和最小值，循环求五个选手的得分，一维数组定义，double定义得分
问题1：不能在数组中输入数
原因：在输出语句之前，没有写for语句
解决方案：查阅课本67页，在输出语句之前，添加了一句for循环
实验二：
程序设计思路：利用if循环判断条件，用数组下标位置比较@和.是否同时存在和前后位置，利用字符串定义
问题1：比较@和.的时候出现了问题
解决方案：利用数组下标比较
（三）代码托管
http://git.oschina.net/hebau_cs15/Java-cs02HQY/commits/master
