Java学习笔记——数组和常见排序
数组
今天任务
1.开发工具eclipse的介绍
2.数组的声明和初始化
3.数组的元素访问以及遍历
4.数组的应用(冒泡排序、选择排序、插入排序、快速排序、顺序查找和二分法查找)
第一节：开发工具的介绍
1.1 工作空间的概念
工作空间（workspace）,是用户在同一个工程中（或者是一个事务）工作环境的集合,简单来说，就是项目存放的位置
就是你项目存放的位置：项目，文件，文件夹
工作空间有明显的层次结构。项目在最顶级，项目里头可以有文件和文件夹
Eclipse的配置 切换为java透视图: window—>Perspective—>open Perspective—>other—>java
重置透视图: window--->Perspective--->reset Perspective
Package Explorer ：包资源管理器,用来管理项目的包
入门演示如何创建项目 ：
file--->New--->Java Project
项目结构 ：
jre :运行环境
src: 存放源码
1 创建包 ，公司域名的倒置 www.baidu.com com.baidu.helloworld com.qf.helloworld 小写
2 创建类，类名HelloWorld
3 编写代码
4 运行 点击run按钮
配置Eclipse
1 修改字体大小 window-->preferences--->输入font---->colors and fonts--->basic--->text font
2 修改编码 utf-8 window-->preferences--->输入 encoding--> workspace--> other utf-8
3 修改代码提示 window-->preferences--->输入 assist --->java--editor> content assist
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ(@,
1.2 常用快捷键的介绍
常见模板代码（代码片段）
main--->主函数
syso--->输出语句
自定模板
window-->preferences-->java--->editor--->templates
添加模板
psvm
public static void main(String[] args){
${cursor}
}
ctrl+D：删除一行
ctrl+shift+f：格式化代码
ctrl+S：保存文件
ctrl+shift+o：导包
ctrl+alt+方向键上下键：向上或向下复制
alt+方向键的上下键：向上或向下移动
alt+shift+j：文档注释
ctrl+/：单行注释
ctrl+/：取消单行注释
ctrl+shift+/：多行注释
ctrl+shift+:取消多行注释
shift+enter：强制向下换行
ctrl+shift+enter 强制向上换行
ctrl+f11:运行
alt+shift+a:矩形选择
1.3 参考资料
可参考http://www.runoob.com/eclipse/eclipse-create-java-project.html
第二节：数组
数组：多个数据的组合。变量是开辟一个空间，而数组是开辟一串连续空间。
数组属于引用类型。
2.1 数组的声明
方式一：数据类型[] 数组名
方式二：数据类型 数组名[]
推荐使用方式一，C#等越来越多的语言已经不支持方式二定义数组
2.2 数组的初始化
Java中的数组必须先初始化，然后才可以使用，所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋初始值
2.2.1 静态初始化
初始化时由程序员指定每个数组元素的初始值，由系统计算数组长度
语法：数组元素类型[] 数组名 = new 数组元素类型[]{元素0，元素1,....};
可简写为：数组元素类型[] 数组名 = {元素0，元素1,....};
说明：任何一个变量都得有自己的数据类型，这里的arr表示数组变量名称，int表示数组中元素的类型，int[]才是数组类型
注意：简写静态初始化只能一条语句完成，不能分割成两条语句。
代码实现：
/*
静态初始化:由我们指定元素的初始值，由系统计算长度或者元素的个数
*/
int[] arr = new int[]{1,56,76,87};
int[] arr1 = {1,56,76,87};
String[] arr2 = new String[]{"434","gfg","gjf545"};
String[] arr3 = {"434","gfg","gjf545"};
//Scanner[] arr4 =
char[] arr5 = new char[]{'2','g','*'};
char[] arr5 ={'2','g','*'};
2.2.2 动态初始化
初始化时程序员只指定数组长度，由系统为数组元素分配初始值
语法：元素类型[] 数组名 = new 元素类型[元素个数或者数组长度]；
系统对初始值分配规则如下：a.整数型为0
b.浮点型为0.0
c.字符型为‘\u0000’(不同的系统平台显示结果不同)
d.布尔类型为false
e.引用类型为null
代码实现：
/*
动态初始化：初始化时由程序员指定数组的长度，系统负责分配元素的初始值
*/
int[] array1 = new int[5];//0
String[] array2 = new String[3];//null
char[] array3 = new char[10];//\u0000
注意：
a.在初始化数组时，不要静态初始化和动态初始化同时使用，也就是说，不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值
b.既然数组也是一种数据类型，则在初始化的时候也可以先声明，再初始化
例如：int[] scores;
scores = new int[3];
2.3 数组的使用
2.3.1 通过下标访问指定元素
注意：1 Java语言的数组索引是从0开始的,数组的下标的最大值长度-1
2不要超出索引的范围，如果超出范围出现异常 java.lang.ArrayIndexOutOfBoundsException
代码实现：
//使用静态初始化的方式定义一个数组
//数组中可以存放重复数据
int[] arr1 = new int[]{2,65,76,83,32,5,5};
//1.访问数组中的元素
//格式：数组名称[下标] 表示获取指定下标所对应的值
//需求：获取下标3对应的元素
int num1 = arr1[3];
System.out.println(num1);//83
System.out.println(arr1[3]);//83
2.3.2 获取数组元素的个数
在Java中，所有数组都提供了一个length属性，通过这个属性可以访问到数组的长度或者数组中元素的个数
代码实现：
//2.获取数组中的元素个数或者数组的长度
//格式:数组名称.length;
int len = arr1.length;
System.out.println("数组arr1的长度为：" + len);
2.3.3 修改数组元素的值
代码实现：
//3.修改数组元素的值
int num2 = arr1[6];
System.out.println(num2);//
//格式：数组名称[下标] = 被修改之后的值
//注意：不管是静态初始化还是动态初始化，都可以采用这种方式修改元素的值
arr1[6] = 100;
System.out.println(arr1[6]);//100
2.3.4 遍历数组
依次访问数组中的每一个元素，获取每个下标对应的元素值
方式一：简单for循环
方式二：增强for循环（foreach）无法使用下标
代码实现：
//4.遍历数组
int n0 = arr1[0];
int n1 = arr1[1];
int n2 = arr1[2];
int n3 = arr1[3];
int n4 = arr1[4];
int n5 = arr1[5];
int n6 = arr1[6];
//1>简单for循环
//i表示下标，0~arr1.length
for(int i = 0;i < arr1.length;i++) {
int n = arr1[i];
System.out.println(n);
}
/*
2>增强for循环【foreach】
JDK1.5之后新增的
优点：用于遍历数组和集合，无需通过数组下标，就可以直接访问数组或者集合中的元素
语法：
for(元素数据类型 变量名：数组名称) {
System.out.println(变量名);
}
*/
//底层工作原理：根据下标获取数组元素
for(int num : arr1) {
System.out.println("增强for循环的结果：" + num);
}
/*
两种遍历方式的选择：不需要知道下标，只需要获取元素值，则采用增强for循环
*/
//需求：打印下标为偶数的元素值【只能采用简单for循环】
for(int i = 0;i < arr1.length;i++) {
if(i % 2 == 0) {
int n = arr1[i];
System.out.println(n);
}
}
2.3.5 数组的内存分配
内存空间:
栈：存储基本类型数据和引用类型的地址，特点：先进后出，一般空间比较小，存取速度较快
堆：存储引用类型数据，特点：空间比较大，存储速度相对较慢
数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存空间，只有当这个引用指向有效的空间时，才可以通过引用去操作真正数组中的元素
结论：数组的引用变量存储在栈空间中，而真正的数组数据存储在堆空间中。
代码实现：
class ArrayUsageDemo04
{
public static void main(String[] args)
{
//使用静态初始化的方式初始化一个数组a
int[] a = {5,7,20};
System.out.println("a的长度为：" + a.length);//3
//使用动态初始化的方式初始化一个数组b
int[] b = new int[4];
System.out.println("b的长度为：" + b.length);//4
b = a;
System.out.println("a的长度为：" + a.length);//3
System.out.println("b的长度为：" + b.length);//3
int num=8;
}
}
2.3.6 使用数组时常见的问题
1>数组越界异常：ArrayIndexOutofBoundsException
出现的时机：当使用了不存在的下标时，则会出现这个错误
0~length - 1
2>空指针异常：NullPointerException
出现的时机：当数组的引用变量赋值为null，还在后面的代码中使用这个引用
2.4 数组的排序
2.4.1 冒泡排序
排序思路：比较两个相邻的下标对应的元素，如果符合条件就交换位置（最值出现在最后位）
代码实现：
class ArraySortedDemo01
{
public static void main(String[] args)
{
int[] arr = {23,54,65,3,5,2,87};
//以升序为例
//外层循环：控制比较的轮数
for(int i = 0;i < arr.length - 1;i++) {
//内层循环：控制每一轮比较的次数和参与比较的下标
for(int j = 0;j < arr.length - 1 - i;j++) {
if(arr[j] > arr[j + 1]) {
//交换位置
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int num:arr) {
System.out.println(num);
}
}
}
2.4.2 选择排序
排序思路：固定一个下标，然后拿这个下标对应的值依次和后面的元素进行比较
代码实现：
class ArraySortedDemo02
{
public static void main(String[] args)
{
int[] arr = {23,54,65,3,5,2,87};
//以升序为例
//外层循环：控制比较的轮数
for(int i = 0;i < arr.length - 1;i++) {
//内层循环:控制每一轮比较的次数，参与比较的下标
for(int j = i + 1;j < arr.length;j++) {
//交换位置
if(arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
for(int num:arr) {
System.out.println(num);
}
}
}
2.4.3 插入排序
排序思路：插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。
代码实现：
public static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int temp = arr[i];
int j = i - 1;
for ( ; j >= 0 && temp < arr[j]; j--) {
arr[j + 1] = arr[j];
}
arr[j + 1] = temp;
}
}
2.4.4 快速排序
排序思路：参考http://developer.51cto.com/art/201403/430986.htm
代码实现：
public static void main(String[] args) {
// TODO Auto-generated method stub
a = new int[] {53, 43, 32, 75, 11, 64} ;
quicksort(0, a.length - 1);
}
public static void quicksort(int left, int right) {
int i, j, t, temp;
if (left > right)
return;
temp = a[left]; // temp中存的就是基准数
i = left;
j = right;
while (i != j) {
// 顺序很重要，要先从右边开始找
while (a[j] >= temp && i < j)
j--;
// 再找右边的
while (a[i] <= temp && i < j)
i++;
// 交换两个数在数组中的位置
if (i < j) {
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
// 最终将基准数归位
a[left] = a[i];
a[i] = temp;
quicksort(left, i - 1);// 继续处理左边的，这里是一个递归的过程
quicksort(i + 1, right);// 继续处理右边的 ，这里是一个递归的过程
}
2.5 数组的查找
2.5.1 顺序查找
查找思路：遍历这个数组，依次把每一位元素和要查找的数据进行比较
代码实现：
class ArraySearchDemo01
{
public static void main(String[] args)
{
int[] arr = {23,54,65,3,5,2,87};
//需求：查找65在数组中的位置
int key = 65;
for(int i = 0;i < arr.length;i++) {
if(key == arr[i]) {
System.out.println(i);
}
}
}
}
2.5.2 二分法查找
查找思路：前提是数组是有序（升序或者降序）的，通过折半来缩小查找范围，提高查找效率
将待查找的元素与中间下标对应的元素比较，如果大于中间下标对应的元素，则去右半部分查找
代码实现：
class ArraySearchDemo02
{
public static void main(String[] args)
{
int[] arr = {12,43,54,65,87,88,90,343};
//待查找的元素
int key = 88;
//相应的下标
int left = 0;
int right = arr.length - 1;
while(left <= right) {
//中间下标
int middle = (left + right) / 2;//取整
if(arr[middle] > key) {
right = middle - 1;
} else if(arr[middle] < key) {
left = middle + 1;
} else {
System.out.println(middle);
break;
}
}
}
}
面试题
1.基本数据类型和引用数据类型之间的区别
基本数据类型的数值储存在栈中，引用数据类型的数值储存在堆中。
String比较特殊，他的储存方式和基本数据类型相同，且一旦声明择不可更改
2.在java中，声明一个数组过程中，是如何分配内存的
初始化之前，会在栈中保存数组名，初始化后会在堆内存中开辟相应大小的空间，然后将其地址赋给栈中的数组名
3.数组的静态和动态初始化有什么不同
数组的静态初始化就是在数组在初始化的时候直接赋值，即int[] arr = new int[]{1,2,3,4} ;
数组的动态初始化就是先确定数组长度，然后再逐个赋值，
即int [] arr = new int[2] ; arr[0] = 1; arr[1] = 2 ;
4.分别使用冒泡和选择对已知数组进行排序
冒泡排序：
int[] arr = {98,34,67,2,14,70} ;
for(int i=0; i arr[j+1]){
int temp = arr[j] ;
arr[j] = arr[j+1] ;
arr[j+1] = temp ;
}
}
}
选择排序：
int[] arr = {98,34,67,2,14,70} ;
for(int i=0; i arr[j]){
int temp = arr[i] ;
arr[i] = arr[j] ;
arr[j] = temp ;
}
}
}