数组
数组是有序的元素序列，用于储存多个相同类型数据的集合。
数组的创建方式有多种，但在创建时都应该指定长度(元素数量)，引用类型。
方式一： String[ ] array = new String[5];
方式二： int[ ] array = new int[ ] {1,2,3,4,5};
方式三： int[ ] array = {1,2,3,4,5};
示例：
public class Demo{
//数组没有创建时值为null
int[] array;
public void method(){
//访问值为null的数组将出现nullPointerException
System.out.println(array[0]);
}
public static void main(String[] args) {
//创建数组的多种方式，数组在创建都应指定长度（元素数量）
//数组是引用类型
//数组创建后具备默认值
//数组创建后，长度不不可变
//创建方式1
int[] array = new int[5];
String array[] = new String[5];
//对数组的元素进行赋值
array[0] = 1;
//访问数组中的元素，通过下标索引
System.out.println(array[0]);
//创建方式2 创建时直接赋值
int[] array = new int[]{1,2,3,4,5,6};
//访问时索引不能超过数组的长度
System.out.println(array[7]);
//创建方式3
int[] array = {1,2,3,4,5,6};
//获取数组的长度,使用length属性
System.out.println(array.length);
//遍历数组的元素
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
}
}
注意事项 ：
- [ ]可以放在数组名的后面；
- 创建数组必须分配数组的长度，创建后具备默认值，且长度不变；
- 访问数组中的元素，通过下标索引访问(访问时索引不能超过数组长度)。
数组的相关属性
| 属性 | 作用 | 示例 |
|---|---|---|
| length | 获取数组中元素的数量(长度) | System.outpprintln(array.length); |
| split | 分割 | String[ ] nameArray = s.split(","); |
| toCharArray( ) | 将字符串转换为数组(char型) | char[ ] array = str.toCharArray( ); |
对数组进行排序：
数组中的排序是将元素按照一定规律依次比较的过程。
import java.util.Arrays;
import java.util.Date;
import com.chiang.Demo2;
public class Demo7 {
//降序
public static final int DESC = 2;
//升序
public static final int ASC = 1;
/**冒泡排序 排序类型 1升序 2降序*/
public void sort1(int[] array, int sortType){
if(sortType == 1){
//外层循环比较轮数
for(int i = 1; i < array.length; i++){
//里层循环比较每轮的次数 -i表示上一轮产生的最大/最小值不需要参与比较
for(int j = 0; j < array.length-i; j++){
//相邻两数的比较
if(array[j] > array[j+1]){
//两数交换
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
else{
//外层循环比较轮数
for(int i = 1; i < array.length; i++){
//里层循环比较每轮的次数 -i表示上一轮产生的最大/最小值不需要参与比较
for(int j = 0; j < array.length-i; j++){
//相邻两数的比较
if(array[j] < array[j+1]){
//两数交换
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
}
/** 选择排序法 */
public void sort2(int[] array){
//外层循环控制比较轮数
for(int i = 0; i < array.length-1; i++){
//里层循环控制每一轮比较的次数
for(int j = i+1; j < array.length; j++){
if(array[i] > array[j]){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
/**快速排序法（二分法） left：左边的起始索引位置 right：右边的起始索引位置*/
public void sort3(int[] array,int left, int right){
//如果排序到最后一位数，右边的索引小于左边的索引时，排序结束
if(left > right){
return;
}
int i = left;
int j = right;
//基准值
int middle = array[left];
//i和j没有汇合时，则两端继续前进
while(i != j){
//先从右往左前进
while(array[j] >= middle && j > i){
j--;
}
//再从左往右前进
while(array[i] <= middle && i < j){
i++;
}
//将i和j对应的数交换位置
int temp = array[j];
array[j] = array[i];
array[i] = temp;
}
//i和j汇合后，交换汇合点与基准值
array[left] = array[i];
array[i] = middle;
//根据新的交汇点分成左右两部分，分别继续排序
sort3(array, left, i-1);
sort3(array, i+1, right);
}
public static void main(String[] args) {
//动态生成一个指定长度的随机数组
Demo2 demo2 = new Demo2();
int[] array = demo2.createRandomArray4(1000000);
Demo7 demo = new Demo7();
//记录算法起始时间
Date start = new Date();
//冒泡排序
demo.sort1(array,Demo7.ASC);
//选择排序
demo.sort2(array);
//快速排序
demo.sort3(array, 0, array.length-1);
//使用Java自带的排序算法（升序）
Arrays.sort(array);
//记录算法结束时间
Date end = new Date();
//计算算法耗时
long time = end.getTime()-start.getTime();
System.out.println("运算耗时："+time+"ms");
}
}
附：产生1~100不重复的随机数
import java.util.Date;
import java.util.Random;
import com.chiang.Demo7;
public class Demo2 {
/** 产生1-100不重复的随机数 */
public int[] createRandomArray1(){
int[] array = new int[100];
Random random = new Random();
//循环的次数
int count = 0;
//如果最后一个元素为默认值0则继续生成随机数
while(array[array.length-1] == 0){
//生成一个1-100的随机值
int n = random.nextInt(100)+1;
//判断是否已经产生过该数据
if(!hasNumber(array, n)){
//先计算写入的索引
int index = searchInsertIndex(array);
//如果没有产生则写入数组
array[index] = n;
}
}
System.out.println("数组产生完毕，共计循环"+count+"次");
return array;
}
/** 递归算法实现 */
public int[] createRandomArray2(){
int[] array = new int[100];
Random random = new Random();
//生成随机数
createData(random, array);
return array;
}
/** 生成随机数 */
public void createData(Random random, int[] array){
//生成一个1-100的随机值
int n = random.nextInt(100)+1;
//判断是否已经产生过该数据
if(!hasNumber(array, n)){
//先计算写入的索引
int index = searchInsertIndex(array);
//如果没有产生则写入数组
array[index] = n;
}
//判断是否需要继续生成
if(array[array.length-1] == 0){
createData(random, array);
}
}
/**查找数组中是否包含数据 */
public boolean hasNumber(int[] array, int n){
for(int i = 0; i < array.length; i++){
if(array[i] == n){
return true;
}
}
return false;
}
/**查找写入数据的索引位置 */
public int searchInsertIndex(int[] array){
int index = 0;
for(int i = 0; i < array.length; i++){
//查找第一次出现的默认值得位置，该位置即数据插入的索引
if(array[i] == 0){
index = i;
break;
}
}
return index;
}
/**性能最好的算法 */
public int[] createRandomArray4(int count){
int[] array = new int[count];
//初始化数组的值
for(int i = 0; i < array.length; i++){
array[i] = i+1;
}
//创建用于接收1-100不重复随机数的数组
int[] randomArray = new int[count];
Random random = new Random();
//随机索引的范围
int range = array.length;
for(int i = 0; i < randomArray.length; i++){
//生成随机索引
int index = random.nextInt(range);
//将索引对应的值写入数组
randomArray[i] = array[index];
//将最后个元素交换至索引位置
array[index] = array[range-1];
//缩小随机索引范围
range--;
}
return randomArray;
}
public void typeResult(int[] array){
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Demo2 demo = new Demo2();
//记录算法起始时间
Date start = new Date();
int[] array = demo.createRandomArray4(1000);
demo.typeResult(array);
//记录算法结束时间
Date end = new Date();
//计算算法耗时
long time = end.getTime()-start.getTime();
System.out.println("运算耗时："+time+"ms");
demo.typeResult(array);
Demo7 demo7 = new Demo7();
demo7.sort1(array, Demo7.ASC);
demo.typeResult(array);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
