黑马程序员技术交流社区

标题: day01-05代码汇总（下） [打印本页]

---

作者: mortonnnn    时间: 2015-7-18 09:03
标题: day01-05代码汇总（下）
数组的表示方法：
int[] arr = new int[3];
int[] arr = new int[3]{1,2,3};
int[] arr = {1,2,3};




逻辑运算符（6）4 +2 :
4:& | && ||
2:! ^


位运算符：
位运算是直接对二进制位的运算

3+2+2：
<< >> >>>
& |
~ ^

~取反：就是对二进制数每一位0变1,1变0
       

对两个整数的值进行互换（可以使用第三方变量）：
class         OperatorDemo{
        public static void main(String[] args){
                int a  = 3 , b = 4;
                int c;

                c = a ;
                a = b;
                b = c;

                }
        }
}


对两个整数的值进行互换（不可以使用第三方变量）
class OperatorDemo{
        public static void main(String[] args){
                int a =3 , b = 4;
               
                a = a ^ b;
                b = a ^ b;
                a = a ^ b;
        }
}




三元运算符：

class Operator {
        public void static main(String args[]){
                int x = 3,y;
                y = (x >1)?100:200;
                System.out.println(y);
        }
}

获取三个数中较大的数：
class Operator {
        public void static main(String args[]){
                int x = 1,y = 2, z = 4,temp,max;
                temp = (x > y)?x:y;
                max = temp > z ? temp : z;
        }
}


if条件语句：


class IfDemo{
        public void static main(String[] args){
                int month = 9;
                if(month <1 || month > 12)
                        System.out.println(month+"月没有对应的季节");
                else if (month >= 3 && month <= 5)
                        System.out.println(month+"月对应春季");
                else if (month >=6 && month <= 8)
                        System.out.println(month+"月对应夏季");
                else if (month >= 9 && month <= 11)
                        System.out.println(month+"月对应秋季");
                else
                        System.out.println(month+"月对应冬季");
        }
}





数组:

找寻最值：

class ArrayDemo {
        public void static main(String[] args){
                int[] arr = {-11,22,44,93,532};
               
                int max   = getMax(arr);

                System.out.println("数组的最大值是" + max);

        }
               
        public int static getMax(int[] arr){
               
                int maxElement = 0;
                if(int x  = 0 ; x < arr.length ; x ++){
                        if(arr[x] > maxElement)
                                maxElement = arr[x];
                }
                return maxElement;
        }
               
}



或者：
class ArrayDemo {
        public void static main(String[] args){
                int[] arr = {22,,23,25,56,76,435,345,34,234,15};
                int maxIndex = getMaxIndex(arr);
                System.out.println("数组的最大值是"+arr[maxIndex]);
        }

        public int static getMaxIndex(int[] arr){
               
                int maxIndex = 0;
                for(int x = 0 ; x < arr.length; x ++){
                        if(arr[x]> arr[maxIndex]){
                                maxIndex = x;
                        }
                }
                return maxIndex;
        }
}



选择排序：
冒泡排序：
每列一直相邻比较，且较大者右移

class  ArrayDemo {
       
        public void static main(String[] args){
       
                int[] arr = {22,44,55,66,77,88,99,9999};
                System.out.print("排序之前的数组 = ”）；
                printArray(arr);
                bubbleSort(arr);
                System.out.print("排序之后的数组 = ");
       
        }

        public void bubbleSort(int[] arr){

                for(int x = 0 ; x <= arr.length - 1 ; x ++){

                        for(int y = 0 ; y <= arr.length - 1 - x ; y ++){

                                if(arr[y] >arr[y+1]){
       
                                        int temp = arr[y];
                                        int arr[y] = arr[y +1];
                                        int arr[y+1] = temp;
       
                                }

                        }

                }

        }

        public void printArray(int[] arr){
               
                System.out.print("[");
                for(int x ; x <= arr.length ; x ++){

                        if(x != arr.length - 1 )
                                System.out.print(","+arr[x]);
                        else
                                System.out.println(arr[x] + "]");

                }

        }

}


二分法（用于有序数列的查找）
class ArrayDemo {
        public void static main(String[] args){
                int[] arr = {21,90,490,1892,2900};
                int index = binarySearch(arr, 490);
                System.out.println("index = "+ index);
        }
       
        public int static binarySearch(int[] arr, int key){
               
                int min = 0;
                int max = arr.length- 1 ;
                int mid = (min +max)/2;

                while(arr[mid] != key){
                        if(arr[mid] < key)
                                min = mid +1;
                        else if (arr[mid] >key)
                                max = mid -1;

                        if(max < min){
                                return -1;
                        }
                        mid = (max +min)/2;
                       
                        return mid;
                }
        }
               
               
       
}

或者（位运算符）：
class ArrayDemo{
       
        public void static main(String[] args){
       
                int[] arr = {21,33,33,14,4546,23,56,20,09};
                int index = binearySearch(arr,23);
                System.out.println("index = " + index);
        }

        public int static binearySearch(int[] arr,int key ){

                int max,min,mid;

                max = arr.length - 1;
                min = 0;

                while(min < max) {

                        mid = (max +min)>>1;
                       
                        if(arr[mid]> key )
                               
                                max = mid - 1;
                        else if(arr[mid] < key)

                                min = mid + 1 ;
                        else
                               
                                return mid;

                }

                return -1;

        }

}

       


二分法在jdk中当然api了：
class ArrayDemo{

        int[] arr = {32,11,89,33,190}
        int index = Array.binarySearch(arr,22);
        System.out.println("index = " + index );

}

但返回值是个负值，因为要索引的数字不包含在数组中的话，返回值为：（-（插入点）-1）




获取一个十进制数字的2,8,16进制的表现方式：





二位数组：
求和：

class Array2Demo {

        public void static main(String[] args){
                int sum;

                int[][] arr = {{3,1,8},{8,2,1},{90,222,124,24}};

                for(int x  = 0 ; x <= arr.length ; x ++ ) {

                        for (int y =  0 ; y <= arr[x].length ; y ++)｛

                                sum += arr[x][y];

                        }
                }
                System.out.println("sum = " + sum);

        }

}





以及所谓的面向对象：（匿名对象的使用）

class Car {
        String color = "yellow ";
        String price = 1000,000;

        public void run(){

                System.out.println("wow!!Its so cool to drive such a good car!");

        }
}

class CarDemo {

        public void static main(String[] args){

                //当对对象仅调用一次时，可以用匿名对象
                new Car().run();


                //匿名对象可以作为实际参数进行传递
       
                show （new Car（））；
       
        }

        public void show（Car car）{

                ajfjsdjflasj

        }

}
       



封装：
将不需要对外提供的内容都隐藏起来，并提供公共方法对其访问，如getXXX，setXXX






构造函数：
函数名与类名相同
没有返回值

多个构造函数的重载，差别在于参数不同

static关键字的特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名所调用

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2