Java基础—数组

最新推荐文章于 2019-06-01 09:53:01 发布
最新推荐文章于 2019-06-01 09:53:01 发布
阅读量573 收藏
点赞数
分类专栏： Java 文章标签： 程序员 java 二维数组
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/heisejiuhuche/article/details/44836137
版权

一、数组的定义

  1. 1.数组的概念
    1. 数组是同一种类型数据的集合，是一个容器，用于存储多个数据。

  1. 2.数组的优点
    1. 数组中的每个元素都有下表值，下标从0开始。下标值方便程序员对数组中的数据进行操作。

  1. 3.数组定义的格式
    1. 1）元素类型[]数组名=new 元素类型[元素个数或数组长度]; 这种定义方法称之为动态定义法。

示例：int[] arr = new int[5];

    1. 2） 元素类型[]数组名= new 元素类型[]{元素，元素，……}; 这种定义方法称之为静态定义法。

示例：int[] arr = new int[] {3,5,1,7};
          int[] arr = {3,5,1,7};

二、引用数据类型内存结构

  1. 1.Java内存结构
    1. 由于Java对不同类型的数据有不同的处理方式，所以Java对内存进行了不同的区域划分。这提高了运算效率，优化了内存管理方式。

    1. 1）栈内存
      1. 栈内存用于储存局部变量。当数据使用完毕之后，其所占空间会自动释放。

    1. 2）堆内存
      1. a. 堆内存用于储存对象和数组，所有通过 new建立的实例都在堆内存中存放；
        b. 每一个对象实例都有一个内存地址；
        c. 实例中的变量都有默认的初始化值；
        d. 实例不再被使用时（没有任何引用指向该实例），该实例会在不确定的时间被垃圾回收器回收，释放内存

  1. 2.数组的内存结构示意图
    1. 数组属于引用数据类型，其内存结构示意图如下：

这里写图片描述

当执行int[] x = new int[3]时，

  1. 1）在栈内存开辟一个内存空间，用于存储变量 x；
    2）在堆内存开辟内存空间，用于存储 new出来的数组对象实例；
    3）将数组对象的内存首地址 (0x0079)赋给 x；
    4）至此， x就是数组对象的引用，指向数组对象

  1. 3.两个引用指向同一数组对象实例 

int[] x = new int[3];
int[] y = x;
y[1] = 89;
x = null;

该代码段中，将数组的内存地址引用赋给了x，也赋给了y。那么x，y就指向了同一数组对象。x，y的内存情况如下图：

这里写图片描述

因此，当x = null执行之后，内存中并没有产生垃圾，因为变量y也指向该数组，该数组仍处于被引用状态。同时，y[1] = 89执行之后，x[1]的值也将变为89，而不是0。

  1. 4.基本数据类型内存结构对比
    1. 引用数据类型中，两个变量指向同一对象实例，其中一个变量对对象的值进行修改，会影响另一个变量，这是引用数据类型的规律。下面对比一下基本数据类型做同样的赋值操作之后的内存示意图。 

int a = 5;
int b = a;
b = 8;

运行结束后，a的值仍旧为5。内存图如下：

这里写图片描述

三、数组操作过程中常见的异常

  1. 1.ArrayIndexOutOfBoundsException数组下标越界异常 

int[] arr = new int[3];
System.out.println(arr[3]);

arr[3]超出下标范围，出现异常。

  1. 2.NullPointerException空指针异常 

int[] arr = new int[3];
arr = null;
System.out.println(arr[1]);

arr被赋值为空，已经无法指向数组对象，再使用arr操作数组，出现空指针异常。

四、排序算法

  1. 1.选择排序
    1. 1）从下标为 0的数开始，逐一和后面的数进行比较，遇到小的数，则交换位置

示例代码：

package test;

/**
 * 选择排序
 * @author jeremy
 * 从下标0开始，将每一个数与后一个数进行比较，如果后一个数大于前一个数，则交换位置
 */

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 11, 7, 5, 18, 34, -6};

        //排序前
        printArray(arr);

        //排序
        selectSort(arr);

        //排序后
        printArray(arr);
    }

    public static void selectSort(int[] arr) {
        for(int x = 0; x < arr.length - 1; x ++ ) {
            for(int y = x + 1; y < arr.length; y ++) {
                if(arr[x] > arr[y]) {
                    int tmp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = tmp;
                }
            }
        }
    }

    public static void printArray(int[] arr) {

        System.out.print("[");
        for(int x = 0; x < arr.length; x ++) {

            //判断如果是不是最后一个元素，在元素后面加逗号，如果是，直接打印并换行
            if(x != arr.length - 1) {
                System.out.print(arr[x] + ", ");
            } else {
                System.out.println(arr[x] + "]");
            }
        }
    }
}

    1. 2）从下标为0的数开始，逐一和后面的数进行比较，如果遇到比自身小的数，让小的数继续和后面的数进行比较，直至发现最小的数，再和比较开始时的第一个数交换位置。效率稍高于第一种选择排序

示例代码：

package test;

/**
 *  从下标为0的数开始，逐一和后面的数进行比较，如果遇到比自身小的数，让小的数继续和后面的数进行比较
 *  直至发现最小的数，再和比较开始时的第一个数交换位置。
 * @author jeremy
 *
 */

public class SelectSort2 {
    public static void main(String[] args) {
    int[] arr = new int[]{3, 11, 7, 5, 18, 34, -6};

        //排序前
        printArray(arr);

        //排序
        selectSort(arr);

        //排序后
        printArray(arr);
    }

    public static void selectSort(int[] arr) {

        //声明最小值的下标，和第三方变量
        int minPos, tmp;

        for(int x = 0; x < arr.length - 1; x ++ ) {
            minPos = x; //假设最小值下标等于第一个数的下标，即为0
            for(int y = x + 1; y < arr.length; y ++) {
                if(arr[y] < arr[minPos]) {
                    minPos = y; //如果后一个数小于minPos下标所在的那个数，则交换下标值，即保证minPos为最小值
                }
            }

            //如果minPos不是最初的那个x的值，即minPos所在位置的数字已经发生变化，则将minPos下标所在位置的值和初始值做交换，得到数组中最小值
            if(minPos != x) {
                tmp = arr[minPos];
                arr[minPos] = arr[x];
                arr[x] = tmp;
            }
        }
    }

    public static void printArray(int[] arr) {

        System.out.print("[");
        for(int x = 0; x < arr.length; x ++) {

            //判断如果是不是最后一个元素，在元素后面加逗号，如果是，直接打印并换行
            if(x != arr.length - 1) {
                System.out.print(arr[x] + ", ");
            } else {
                System.out.println(arr[x] + "]");
            }
        }
    }
}

  1. 2.冒泡排序
    1. 每一次循环，确定一个最大的数，并让最大的数下沉到最后，让较小的数逐次上升。

示例代码：

package test;

/**
 * 冒泡排序：相邻两个数进行比较，遇到较小的数则交换位置。
 * 每一次比较完成，则确定一个最大的数。
 * @author jeremy
 *
 */

public class BubbleSort {
    public static void main(String[] args) {

        int[] arr = new int[]{3, 11, 7, 5, 18, 34, -6};

        printArray(arr);

        bubbleSort(arr);

        printArray(arr);
    }

    public static void bubbleSort(int[] arr) {

        int tmp;

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

            //arr.length - x保证每次比较之后，最后一个元素不参与比较
            //arr.length - x -1保证下标y + 1不会越界
            for(int y = 0; y < arr.length - x - 1; y ++) {
                if(arr[y] > arr[y + 1]) {
                    tmp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y + 1] = tmp;
                }
            }
        }
    }

    public static void printArray(int[] arr) {

        System.out.print("[");
        for(int x = 0; x < arr.length; x ++) {

            //判断如果是不是最后一个元素，在元素后面加逗号，如果是，直接打印并换行
            if(x != arr.length - 1) {
                System.out.print(arr[x] + ", ");
            } else {
                System.out.println(arr[x] + "]");
            }
        }
    }
}

  1. 3.真实开发，请使用Arrays.sort()方法…

五、数组查找

  1. 1.折半查找

示例一：

package test;

/**
 * 值班查找的前提是数组是有序数组
 * 折半查找1：当中间值等于目标值的时候，结束查找，并返回查找结果
 * @author jeremy
 *
 */

public class HalfSearch1 {
    public static void main(String[] args) {
        int[] arr = new int[]{-6, 2, 5, 8, 19, 21, 33, 66, 120, 211};

        System.out.println("index = " + halfSearch(arr, 2));
    }

    public static int halfSearch(int[] arr, int key) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (arr.length - 1) / 2;

        while(arr[mid] != key) {
            if(arr[mid] < key) {
                min = mid + 1; //目标数大于中间数，较小值的下标等于中间数下标+1
            } else {
                max = mid - 1; //目标数小于中间数，较大值的下标等于中间数下标-1
            }
            //如果较小值的下标大于了较大值的下标，说明目标数不存在，则返回-1
            if(min > max) {
                return -1;
            }
            mid = (min + max) / 2;
        }
        return mid;
    }

}

示例二：

package test;

/**
 * 折半查找2：当较小值下标小于等于较大值下标时，继续查找，直到找到目标数；如果不存在，返回-1
 * @author jeremy
 *
 */

public class HalfSearch2 {
    public static void main(String[] args) {
        int[] arr = new int[]{-6, 2, 5, 8, 19, 21, 33, 66, 120, 211};

        System.out.println("index = " + halfSearch(arr, -6));
    }

    public static int halfSearch(int[] arr, int key) {
        int min = 0;
        int max = arr.length - 1;
        int mid;

        while(min <= max) {
            mid = (min + max) >> 1;
            if(arr[mid] < key) {
                min = mid + 1;
            //这里一定要写上else if，因为while条件中没有用数组的具体值做比较
            //因此如果找到了相等的值，而没有判断条件来做出返回动作，程序会出错，即查找第二个数字的时候
            //返回的还是下标0
            } else if(arr[mid] > key) {
                max = mid - 1;
            } else {
                return mid;
            }
        }
        return -1;
    }
}

  1. 2.折半查找拓展
    1. 在有序数组中插入一个数，使数组仍保持有序。

示例代码：

package test;

/**
 * 在一个有序数组中插入一个数字，使得插入数字后的数组仍然保持有序
 * @author jeremy
 *
 */

public class InsertNumber {
    public static void main(String[] args) {
        int[] arr = new int[]{-6, 2, 5, 8, 19, 21, 33, 66, 120, 211};

        System.out.println("Insert Position is: " + insertPos(arr, 34));
    }

    public static int insertPos(int[] arr, int key) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;

        while(min <= max) {
            if(arr[mid] < key) {
                min = mid + 1;
            } else if(arr[mid] > key) {
                max = mid - 1;
            } else {
                return mid;
            }
            mid = (max + min) / 2;
        }
        return min; //如果找不到目标数字，直接返回目标数组前一个数的下标，就是目标数字的插入位置
    }

    public static void printArray(int[] arr) {

        System.out.print("[");
        for(int x = 0; x < arr.length; x ++) {

            //判断如果是不是最后一个元素，在元素后面加逗号，如果是，直接打印并换行
            if(x != arr.length - 1) {
                System.out.print(arr[x] + ", ");
            } else {
                System.out.println(arr[x] + "]");
            }
        }
    }
}

六、进制转换

  1. 1.十进制转二进制

示例代码：

package test;

/**
 * 十进制转换为二进制数
 * @author jeremy
 *
 */

public class ToBinary {
    public static void main(String[] args) {
        toBin(6);
    }

    public static void toBin(int num) {
        StringBuffer sb = new StringBuffer();

        while(num > 0) {
            sb.append(num % 2); //模2，将余数存储到StringBuffer当中
            num /= 2; //原数字除以2，准备继续做模运算
        }
        System.out.println(sb.reverse()); //用sb对象的reverse()方法，反向打印出结果
    }
}

  1. 2.十进制转十六进制

示例代码：

package test;

/**
 * 十进制转十六进制
 * @author jeremy
 *
 */

public class ToHex {
    public static void main(String[] args) {
        toHex(60);
    }

    public static void toHex(int num) {

        int tmp;

        StringBuffer sb = new StringBuffer();

        for(int x = 0; x < 8; x ++) {

            tmp = num & 15;

            if(tmp > 9) {
                sb.append((char)(tmp - 10 + 'A')); //如果&15之后的数大于9，则转换成字母
            } else {
                sb.append(tmp);
            }

            num = num >>> 4; // & 操作结束，原数字右移4为，准备下一次 & 操作
        }

        System.out.println(sb.reverse()); //反向输出结果

    }
}

  1. 3.查表法十进制转十六进制

示例代码：

package test;

/**
 * 查表法十进制转十六进制
 * @author jeremy
 *
 */

public class ToHexTable {

    //声明十六进制表
    private static char[] ch = new char[]{'0', '1', '2', '3'
                            , '4', '5', '6', '7'
                            , '8', '9', 'A', 'B'
                            , 'C', 'D', 'E', 'F'};

    private static  char[] result = new char[8];

    public static void main(String[] args) {
        toHex(60);
    }

    public static void toHex(int num) {

        int tmp;
        int pos = result.length; //声明一个指针，用于字符数组从最后一个开始储存十六进制数

        while(num != 0) { //判断num是否大于0，如果等于0，则不需要再进行右移操作，有效位已经全部转换为十六进制

            tmp = num & 15; //& 15 取出有效位的十六进制数

            result[--pos] = ch[tmp]; //从数组的最后以为开始储存查表得出的十六进制数

            num = num >>> 4; //右移4位
        }

        //从有效位开始打印
        for(int x = pos; x < result.length; x ++) {
            System.out.print(result[x]);
        }

    }
}

  1. 4.抽取进制转换共性代码

示例代码：

package test;

/**
 * 将查表法中的代码抽取，提供方法计算十进制转其他进制
 * @author jeremy
 *
 */

public class ToAllNumberFormat {
    public static void main(String[] args) {
        toBin(6);
        toBin(-6);
        toOct(60);
        toOct(-60);
        toHex(60);
        toHex(-60);
        toBin(0);
    }

    //十进制转二进制
    public static void toBin(int num) {
        formatTrans(num, 1, 1);
    }

    //十进制转八进制
    public static void toOct(int num) {
        formatTrans(num, 7, 3);
    }

    //十进制转十六进制
    public static void toHex(int num ) {
        formatTrans(num, 15, 4);
    }

    public static void  formatTrans(int num, int base, int offset) {

        //判断如果要转换的十进制数为0，直接输出0，并结束方法
        if(num == 0) {
            System.out.println(0);
            return;
        }

        //声明十六进制表，该表包含八进制表和二进制表
        char[] ch = new char[]{'0', '1', '2', '3'
            , '4', '5', '6', '7'
            , '8', '9', 'A', 'B'
            , 'C', 'D', 'E', 'F'};

        //声明32位数组，该数组包含能储存八进制和十六进制数
        char[] result = new char[32];

        //声明指针，用于存储数据
        int pos = result.length;

        while(num != 0) {
            result[--pos] = ch[num & base];
            num = num >>> offset;
        }

        for(int x = pos; x < result.length; x ++) {
            System.out.print(result[x]);
        }
        System.out.println();
    }
}

七、二维数组

  1. 1.二维数组的定义
    1. 1） int[][]arr=newint[2][4];
      1. 1> 定义了名称为 arr的二维数组；
        2> 二维数组中有 2个一维数组；
        3> 每一个一维数组中有 4个元素；
        4> 一维数组的名称分别为 arr[0], arr[1]；
        5> 给第一个一维数组1下标位赋值为 78写法是： arr[0][1]=78;

    1. 2） int[][]arr=newint[3][];
      1. 1> 二维数组中有3个一维数组；
        2> 每个一维数组被默认初始化为空值 null；
        3> 可以对这个三个一维数组分别进行初始化： 

arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];

    1. 3） int[][]arr={{3,5,2},{2,6,7},{9,2,1,6}};
      1. 1> 定义一个名称为 arr 的二维数组；
        2> 二维数组中的有三个一维数组；
        3> 每一个一维数组中具体元素也都已初始化；
        4> 第一个一维数组 arr[0]={3,5,2};
        5> 第二个一维数组 arr[1]={2,6,7};
        6> 第三个一维数组 arr[2]={9,2,1,6};
        7> 第三个一维数组的长度表示方式： arr[2].length;

  1. 2.二维数组声明和求和 

package test;

/**
 * 声明一个二维数组，遍历求和
 * @author jeremy
 *
 */

public class TwoDArray {
    public static void main(String[] args) {
        int[][] arr = new int[][]{{2, 3, 5, 1}, {5, 77, 6, 10}, {4, 13, 17, 7}, {8, 9, 0, 11}};

        int sum = 0;

        //遍历二维数组，并求和
        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);
    }
}

  1. 3.小细节
    1. int[] x, y[];
      这样的声明方式，x是一维数组，y是二维数组。

八、知识拓展

  1. 数组的复制。使用 java.lang.System类的静态方法：

  1. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

  1. 可以用于数组 src从第 srcPos项元素开始的 length个元素拷贝到目标数组 dest从 destPos项开始的 length个位置。如果源数据数目超过目标数组边界将抛出 IndexOutOfBoundsException异常。

示例代码：

package test;

/**
 * 测试System类的arraycopy方法
 * @author jeremy
 *
 */

class TestArrayCopy {
    public static void main(String[] args) {
    String[] s = {"Microsoft", "IBM", "SUN", "Oracle", "Apple"};
    String sBak[] = new String[6];

    //public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
    //src:原数组；srcPos:从原数组第srcPos个元素开始拷贝；dest:目标数组；destPos:从目标数组中的destPos位开始拷贝；
    //length；拷贝多少个原数组中的元素
    System.arraycopy(s, 0, sBak, 0, s.length);

    for(int i = 0; i < sBak.length; i ++) {
        System.out.print(sBak[i] + " ");
    }

    System.out.println();

    int[][] array = {{1, 2}, {1, 2, 3}, {3, 4}};
    int[][] arrayBak = new int[3][];

    System.arraycopy(array, 0, arrayBak, 0, array.length);

    arrayBak[2][1] = 100;

    for(int i = 0; i < array.length; i ++) {
        for(int j = 0; j < array[i].length; j ++) {
            System.out.print(array[i][j] + " ");
        }
        System.out.println();
    }

    }
}
0pr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础 数组
11-21
java基础 数组
js 解决 Array.fill()参数为对象指向同一个引用地址
^_^
02-23 470
最近写项目过程中总是想写出漂亮的代码，一行代码搞定绝不用两行，也是踩了fill这个坑。例如一个数组中想填充一些指定的数据。解决方案：使用map返回出不同的引用的地址注意：对象要用 小括号包裹 否则函数会以为是函数体，默认不写return 返回undefined。那么结果就会出现[1, 1, 1, 1, 1, 1, 1, 1, 1, 1] 十对应的1个。输出结果：[{a:1}, {a:1}, {a:1}, {a:1}, {a:1}]如果呢fill 这个方法接受的值是一个引用数据类型，那么他们会指向同一个地址。
JAVA两个引用指向同一个数组
chen404897439的博客
06-01 1328
在这段程序中，arrayB是通过arrayA赋值得到的，并不是NEW出来的，所以他们内部存储的地址值是一样，他们指向的是同一个数组。 arrayA与arrayB即为引用。可以理解为C语言中的指针，都是存储一个内存地址值，指向一块内存。 引用与指针的区别： 1.指针是占用一块内存的，在32位电脑当中，占用4个字节，在64位中占用8个字节。所以指针也是有地址的，比如说二级指针。引用并没有地址，只是一...
引用数据类型----数组（数组与内存控制）-----数据结构
Mar.三月
10-20 280
通过数组元素的索引来操控内存中的数据，数组，本质上是一种数据结构，他以远远的超出了数据类型的范畴，数组这种数据结构用来帮助程序员去在内存中组织大量的数据，，并且组织后的数据连续存储在计算机的内存中；但他又是引用类型的变量，数组元素的值=指向对象的地址值。 数组中的每一个变量的类型都是引用类型，通过数组去将数据存在内存里，通过数组在内存中取数据 数组使用的时候需要初始化，初始化的时候数组在内存中...
java--浅显内存结构之数组
风吹海洋浪的博客
09-06 309
数组本身为引用数据类型 分为：一维数组 和  二维数组 一维数组： 可以理解为 将相同的数据放到一块 一维数组在内存中结构： 例如：int[]   one =new int[4];            one[0]=27;            one[3]=37; 整体的内存分为以下结构： 栈：存放 局部变量  、对象的引用 堆：new出来的新东西   方法区：包括常...
java 基础 数组对象
08-17
java 面向对象 数组对象的基本概念 希望对你们有所帮助
java数组基础详解
08-28
主要介绍了Java数组基础详解，具有一定参考价值，需要的朋友可以了解下。
Educoder题目：Java入门 - 数组基础答案解析.md
11-01
Educoder题目：Java入门 - 数组基础答案解析
Java基础之数组拷贝
12-22
在java中，我们可以将一个数组变量直接拷贝给另一个数组变量。但拷贝后，两个数组变量引用的是同一个数组。若改变其中一个数组中的内容，另一个数组也会同时改变。 （注：如果想打印数组内的所有值，可以使用Arrays....
JavaEnhance——类加载器
0pr
05-17 2202
一概述 二委托机制 三自定义类加载器 一、概述1.类加载器的定义所有Java类在使用的时候都必须通过类加载器加载到内存。Java虚拟机可以安装多个类加载器，系统默认的，有三个主要的类加载器：BootStrap, ExtClassLoader, AppClassLoader。它们分别负责加载特定位置的类。2.类加载器的性质类加载器也是Java类。因此，类加载器也要被一个类加载器加载，才能工作。这么说来
Java基础—for循环的嵌套
0pr
04-02 1017
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-利用for循环的嵌套打印六种类型的 * 形三角。示例一：package test;/** * 打印如下图形： * ***** * **** * *** * ** * * *
Java基础—反射机制
0pr
04-18 717
———Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ———一概述 二反射 三反射中的类 四ArrayList-HashSet的比较及HashCode分析 五框架的概念即用反射技术开发框架的原理 六内省 一、概述反射是JDK1.2以来就有的特性。学习反射，首先要了解Class这个类，1.Class类 Java中的类描述一类事物的共性，该类事物有什么属性，没有什么属性。但
JavaEnhance——枚举、注解及泛型
0pr
05-16 681
枚举一、概述如果一个变量的取值要被限定在一定的范围内，例如星期的取值，限定在1~7的范围内，并且想要在编译期就能指出变量取值超出范围的错误，就可以使用枚举。枚举相当于一个类，其中也可以定义构造方法，成员变量，普通方法和抽象方法。二、枚举的应用1.使用普通类模拟枚举使用普通类模拟枚举的时候，首先将构造方法私有化，然后在类的内部创建常量，那么其他类在调用这个类的时候，只能得到模拟枚举类中的常量，不能ne
面试
0pr
04-29 662
毕业之后突然来个黑马的面试，还有点小小的紧张。居然会紧张，想不通。可能是太想进黑马，思想负担比较重。找理由嘛。自黑开始~早上早饭也吃了，营养够的嘛，感觉回答问题的时候磕磕巴巴的，好的是都回答上来了。内存不足，运行缓慢，这脑子不经常用用连句整个的句子都说不清楚，逻辑也超级混乱。唉，如果上天再给我一次机会，我一定会先夸美女老师长得漂亮，一紧张，套近乎的本领全忘了。这是Java基础系列博客之后的第一篇麻弄
Java基础—面向对象（一）
0pr
04-02 653
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-面向对象（一）一、理解面向对象面向对象作为一种编程思想，其本质是基于面向过程的。相对于强调功能行为的面向过程变成方式而言，面向对象强调的是功能的封装，形成具备一定功能的对象。面向对象的思维方式，符合人们的思考习惯，可以将复杂的事情简单化。从面向过程到面向对象，程序员完成了从执行者到指挥者的角色转变。在使用面向对象概
Java基础—网络编程（一）
0pr
04-16 651
———Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ———一网络模型 二网络通信三要素 三IP地址 四通信协议 五网络编程常用类 网络编程（一）一、网络模型1.OSI参考模型 OSI网络模型的每一层，都有自己特有的数据封装特征信息。两台主机通信，首先在应用层将数据封装。将会给数据加上应用层的特征信息，传递给OSI网络模型的下一层表示层；表示层也会给数据加上自己特有的特
Java基础—String类
0pr
04-06 575
———Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ———一String类 二StringBuffer类 三StringBuilder类 四基本数据类型包装类 一、String类1.概述 1）字符串解读 String s1 = "abc"; s1是一个类类型变量，"abc"是一个对象。只要在""里的，都是对象。字符串最大的特点在于，一旦初始化，就不可以改变。字符串，
Java基础—IO流（三）
0pr
04-13 559
———Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ———IO流（三）File类一、概述File类用于将文件或文件夹封装成对象，方便对文件和文件夹的属性信息进行操作。该类可以作为参数传递给IO流的构造函数，弥补流对象在操作文件和文件夹上的缺陷。二、File类的使用1.构造方法 1）File(String FileName) 示例：File f1 = new File
java入门数组基础educoder
最新发布
06-28
Java中的数组是一种存储多个相同数据类型的变量的容器。它可以用来存储基本数据类型，例如int、float等，也可以用来存储对象。在Java中，数组是对象，因此它有一些特殊的属性和方法。 创建数组的语法格式如下： ``...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值