数组 冒泡排序法

数组的定义

	public static void main(String[] args) {
		
		int [] age;//定义数组时中括号中不能指定长度
		double money [];//定义数组时中括号可放在名字前面也可以放在名字后面
		String [] name;
	}
package com.neuedu.demo;
/*
 * 数组 是相同类型的数据按照顺序组合后的一种引用类型,可以看做是一个容器
 * 数组的特点:长度一经定义不可改变
 * 如何定义数组:
 * 		按照长度(动态初始化数组):数组中有内容  内容是默认值
 * 			第一种:1.先声明 2.再赋值
 * 			int [] arr; arr = new int[3];
 * 			第二种:声明并且赋值
 * 			int [] arr = new int [3];
 * 		按照内容(静态初始化数组):数组有长度 长度是元素的个数
 *  		第一种:int []  arr = {1,2,3,4};
 *  		第二种:int [] arr = new int [] {1,2,3,4,5};
 */
public class 数组 {
	public static void main(String[] args) {
		//第一种:1.先声明 2.再赋值
		int [] arr;//先声明
		arr = new int [3];//再赋值 3为长度
		//第二种:声明并且赋值
		int [] arr2 = new int [3];
		
		//按照内容定义
		//第一种:
		int [] arr3 = {1,2,3};
		//第二种
		int [] arr4 = new int [] {1,2,3,4};
		
	}

}

数组的创建 数组的赋值

数组的创建(赋值)

数组创建可以理解为数组的赋值 同时指定长度
创建数组时 必须指定长度 长度不可更改

		int [] arr;
		//数组创建可以理解为数组的赋值 同时指定长度
		arr = new int [5];//创建数组时 必须指定长度 长度不可更改
		//或者可以写成 int []arr = new int [5];

栈区 堆区

引用类型在栈区存储的是堆区里开辟空间的所在地址

基本类型是直接在栈区里存储定义的数据

java程序运行时 数据都是在内存中储存
java虚拟机运行时会把内存划分成不同的区域来存储不同的数据
主方法一运行,虚拟机就会为主方法分配一个栈区(内存区域)
栈区中存储的是主方法中定义的变量

引用类型 存储的是new开辟的堆空间的地址
new关键字意味着在堆区开辟一块新空间
引用类型的好处是节约内存的使用

数组创建是有默认值的
数组中的数据有索引或下标来去进行区分 索引或下标从0开始 到长度-1
数组的空间是连续的

String类型定义的数组，默认值是null

char类型定义的数组，默认值是空格字符

浮点类型定义的数组，默认值是0.0

boolean类型数组的默认值是false

数组的初始化 赋值

有两种方法 定义变量同时初始化只能使用一次 另外一种可以使用多次

		//创建数组同时为每一个元素赋值
		int []a = {1,2,3}; 
		//a = {4,5,6};只能在定义变量时使用一次
		
		String []n = new String [] {"速度与激情9","超越"};
		n = new String [] {"abc","123"};//可以使用多次

数组元素

元素下标从0开始一直到长度-1

		int []a = new int [3];
        //通过元素的下标值访问某一个具体的元素
		System.out.println(a[0]);//a元素默认值都为0
		a[1] = 100;
		System.out.println(a[1]);//此时结果为100 a数组中第二个元素为100

        int []b = a;
		b[2] = 1000;
		System.out.println(a[2]);
        //此时a[2]为1000,因为a和b储存的是同一个数组地址,b变化 a就也变化
		

数组的遍历

for循环 和 foreach

        String [] n = {"可乐","雪碧","冰红茶","气泡水","大窑"};
		//i 用来控制循环次数 同时它代表了元素的下标
		//遍历指的是从数组第一个元素开始 依次访问到最后一个
		for (int i = 0; i < n.length; i++) {
			System.out.println(n[i]);
		}
		
		//简化版for循环 foreach
        //foreach循环 只能使用数组中的每一个数据 不能对数组中的数据进行修改
		int [] a = {1,-10,100,5};
		for (int t : a) {
			System.out.println(t);
		}
		

数组越界会出现异常(整数除0也是)

冒泡排序法

public static void main(String[] args) {
		int [] a = {2,4,5,8,3,1,0};
        //冒泡的次数 长度-1
		for (int i = 0; i < a.length-1; i++) {
        //冒泡的过程 从数组第一个元素开始依次两两比较 大的在后 升序 小的在后 降序
			for (int j = 0; j < a.length-1-i; j++) {
        //升序 前面的比后面大 需要交换 
		//降序 前面比后面小 需要交换
				if (a[j]>a[j+1]) {
					int c = a[j];
					a[j] = a[j+1];
					a[j+1] = c;
				}	
			}
		}
		for (int i : a) {
			System.out.print(i+" ");//输出结果从小到大
		}
	}

数组的复制(覆盖)

System.arraycopy(源数组, 源数组开始下标, 目标数组, 目标数组开始下标, 复制元素个数);

int [] arr = {1,2,3,4,5};
		int [] arr2 = {6,7,8,9,10,11,12,13,14};
		//数组的复制 第一个参数是源数组(要被复制的数组) 第二个表示源数组开始的位置(索引) 第三个参数目标数组(复制到的数组) 
		//第四个参数是目标数组开始的位置 第五个参数是目标数组元素的个数(前多少个)
		System.arraycopy(arr, 0, arr2, 0, 5);
		
		//遍历数组
		for (int i:arr2) {
			System.out.println(i);
		}//1 2 3 4 5 11 12 13 14

数组的排序(升序)

Arrays.sort(数组名);

public static void main(String[] args) {
		
		int [] arr = {1,6,2,3,9,4,5,7,8};
		//数组排序
		Arrays.sort(arr);
		
		//遍历数组
		for(int i : arr) {
			System.out.println(i);
		}
	}