JavaME知识

1. Java概览

1.1. 特点

1. 面向对象
2. 安全简单
3. 跨平台，在安装了JVM的平台可以任意运行

1.2. 三大版本

• JavaME：Java微型版----作用于机顶盒或嵌入式
• JavaSE：Java标准版----作用于一些桌面程序
• JavaEE：Java企业版----作用于各大程序或网站平台

1.3. JDK/JRE/JVM之间的关系

• JDK：Java开发工具包
• JRE：Java运行环境
• JVM：Java虚拟机
  JDK > JRE > JVM

1.4. Java程序运行过程

• .java(源文件)—编译—.class(字节码)—运行解析
• .java源文件：给程序员看的
• .class字节码文件：里面是二进制，给计算机解析的

1.5. 包的概念(package)

作用：可以把src下的类进行清晰的划分，方便使用，可以解决同名问题
注意：

• 如果是用一个包类相互使用—直接使用即可
• 如果是不同包中类相互使用—需要使用import进行导包
• java.lang中内容直接使用不需要导包
  package：当前类所在的包
  import：引入其他类所在的包

1.6. 标识符命名规范

• 项目名称：全小写
• 包名称：全小写，采用公司域名倒序
• 类名：大驼峰
• 变量名：小驼峰
• 常量名称：全大写

2. 数据类型

基本数据类型：八种

1. 整数型：byte、short、int(默认)、long
2. 浮点型：float：精确到7位，后缀F/f、double(默认)：精确到15位
3. 字符型：char
4. 布尔型：boolean
   引用数据类型：类、抽象类、接口、枚举、…
   

3. 数组

数组：存储多个相同数据类型的有序集合

3.1. 数组的内存特征

• 栈内存：存储基本数据类型和引用数据类型地址的空间
• 堆内存：一般new出来的值，对象真实的值保存在堆内存中；
  字符串常量池：存储字符串的值
  

1. 基本数据类型创建的变量，存储在栈中，占用一块内存，是方法中的内部的局部的变量；数据量比较小，是一种临时的使用
2. 引用类型的数据创建的变量，存储在堆上，栈内存引用堆内存上的地址，占用两块内存；不仅是当前方法使用，范围更大的数据，数据量比较大，是一种持久性的存储

• 数组一旦创建，其值可以更改，长度不可更改
• 在内存中分配连续的空间，每个元素占用的空间大小是相同的
• 同一个数组其元素的类型必须是相同类型，不允许出现混合类型
• 数组类型可以是任何数据类型，包括基本类型和引用类型
• 数组变量属于引用数据类型
• 数组存储数据增加和删除数据比较麻烦，但是根据索引查询数据是非常快的

3.2. 数组的默认值

• byte/short/int/long => 0
• float/double => 0.0
• char => ‘\u0000’
• boolean => false
• String等引用类型 => null

3.3. 数组的定义方式

int[] arr = {1,2,3};
int[] arr1 = new int[]{1,2,3};
int[] arr2 = new int[3];

3.4. 数组遍历

1. for
2. foreach：foreach循环中没有索引，不能通过中间变量修改数组的元素，当不需要使用数组索引，也不需要修改数组元素时使用foreach

int[] arr = {1,2,3,4,5};
for(int a: arr) 
{
}

3.5. 数组的缩容（删除元素）

1. 移动元素
   好处：不需要创建新数组，省内存，快
   缺点：容易造成数组结尾有闲置元素位，需要一个单独变量来统计数组中有效元素的个数

/*int[] arr={5,9,7,3,4,6,8,2,1,0}
删除数组中索引为6的元素*/
public static void test7() {
      int[] arr = {5, 9, 7, 3, 4, 6, 8, 2, 1, 0};
      int idx = 6;
      for (int i = idx; i < arr.length - 1; i++) {
          arr[i] = arr[i + 1];
      }
      arr[arr.length - 1] = 0;
      for (int i : arr) {
          System.out.println(i);
      }
}

2. 创建新的数组
   好处：不会有空余的元素位
   缺点：需要重新创建数组，交给java垃圾回收机制自动处理

// 方法2
public static void test8() {
        int[] arr = {5, 9, 7, 3, 4, 6, 8, 2, 1, 0};
        int[] newArr = new int[arr.length - 1];
        int idx = 6;
        System.arraycopy(arr, 0, newArr, 0, idx);
        System.arraycopy(arr, idx + 1, newArr, idx + 1 - 1, arr.length - (idx + 1));
        for (int i : newArr) {
            System.out.println(i);
        }
    }

数组存储数据的特点：

• 数组的数据在内存上是连续的
• 根据索引查询数据快
• 面对数据的增加和删除，需要大量移动元素或者重新创建数组，一般经常修改或查询，但是基本不会增加和删除的数据适合使用数组存储

3.6. 数组工具类

• Arrays.binarySearch(arr, val)：在数组中快速查询给定元素出现的位置，如果没找到，返回负数，Arrays.binarySearch在使用时，要求数组必须是升序的
• Arrays.toString(arr)：快速的遍历数组，返回给定数组的字符串表达形式
• Arrays.copyOf(src, srcPos, dest, destPost, length)：复制数组，获得数组副本

public static void main() {
        int[] arr = {12, 4, 5, 6, 85, 54, 74, 95, 65, 82, 26, 34};
//        System.out.println(Arrays.toString(arr));
//        Arrays.sort(arr);
//        System.out.println(Arrays.toString(arr));
        int idx = Arrays.binarySearch(arr, 6);
        System.out.println(idx);

        String arrs = Arrays.toString(arr);
        System.out.println(arrs);

        int[] arr1 = {1, 2, 3, 4, 5, 6};
        // 将arr1存储的引用地址复制给arr2
        int[] arr2 = Arrays.copyOf(arr1, arr1.length);
        arr1[0] = 100;
        System.out.println(Arrays.toString(arr1)); // [100, 2, 3, 4, 5, 6]
        System.out.println(Arrays.toString(arr2)); // [1, 2, 3, 4, 5, 6]
    }

3.7. 冒泡排序

public static void test11() {
        int[] arr = {12, 4, 5, 6, 85, 54, 74, 95, 65, 82, 26, 34};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

3.8. 二维数组

3.8.1. 创建

• 静态创建：int[][] arr = {{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};
• 动态创建：int[][] arr = new int[外围数组长度][内部小数组长度];