java基础--数组以及常用操作

package com.zemeng;

import java.util.Arrays;
import java.util.Date;

public class ArrayDemo {

public static
void main( String[] argv ){

/*
 *  java数组:
 * 
 * 一 概述：
 * 1.数组是同一种类型数据的集合，数组就是一个容器，用来装载其他一系列元素；
 * 
 * 2.数组是一种对象，数组变量是引用类型；数组是分配在堆内存中的；且数组中的每个元素都相当于该对象的成员变量;
 * 数组中的元素会被自动初始化，如果是基础类型数据，会被初始化为0；
 * 如果是引用类型数据，会被初始化为null；
 * 数组中存储的是对象的引用类型，而不是对象；且默认的初始化是为null，而不是给你创建一个对象并让该元素指向；

 * 
 * 3.数组可以存储任意类型的变量，但是一旦定义之后，能存储的数据类型也就随之确定;
 * 
 * 4.数组自动给数组中的元素从0开始编号，方便操作这些元素.
 * 
 * 5.特点:
 * (1) 数组一旦定义，数组的长度就被确定，且无法改变；
 * (2) 数组的元素可以通过下标获取，并且可以下标形式，对数组元素的值进行修改；
 * 
 * 

   二 数组对象的创建 （new）:
 * 方式1：
 * 元素类型[] 数组名 = new 元素类型[数组长度];
 * 
 * 方式2：（ 常量形式声明，数组长度由元素的个数自动确定 ）
 * 元素类型[] 数组名 = { 元素1， 元素2， 元素3 }
 */

  /* 代码： 数组的创建 */
int[]
a1 = new int[5];
int[]
a2 = {1,2,3,4,5};

 /* 代码： 数组的遍历 */
for(
int i=0; i<a1.length;
i++ ){

System.out.println(
a1[i] );
System.out.println(
a2[i] );
}

 /* 数组元素的获取或者赋值 */
a1[0] = 20;
a1[1] = 10;
int
value0 = a1[0];
int
value1 = a1[1];

/*  数组常见异常:
 * 1.下标越界：
 * 因为数组的下标从0开始，所以数组中元素的index范围为 0~length-1;
 * 
 *  2.空指针异常：
 *  数组是引用类型，有可能指向的是null;
 * */

/* 数组的常见使用
 * 
 *  1. 求数组中的最大最小值
 *  2. 直接排序
 *  3. 冒泡排序
 *  4. 折半查找（二分法）
 *  5. 数组翻转
 *  */

/* 求最大最小值 */

int max;
int min;
int[] arrInt = {1,-3,5,6,7,33,33,2,54,6,4,3};
if( arrInt ==
null || arrInt.length==0  ){
return;
}
max =
min = arrInt[0];
for( int
i=1; i<arrInt.length;
i++ ){

if(
max < arrInt[i] ){

max =
arrInt[i];
}
if(
min > arrInt[i] ){

min =
arrInt[i];
}
}
System.out.println(
"max:"+max+"  min:"+min );

/* 直接排序 */
for(
int i=0;
i<arrInt.length-1;
i++ ){ /* 第一个元素自然有序，所以只要排序n-1次 */

int
temp = arrInt[i];
for(
int j=i+1;
j<arrInt.length;
j++ ){ /* n个元素比较n-1次 */

if(
temp > arrInt[j] ){

arrInt[i] =
arrInt[j];
arrInt[j] =
temp;
temp =
arrInt[i];
}
}
}

for( int
i=0; i< arrInt.length;
i++ ){

System.out.print("   "+arrInt[i]);
}

/* 冒泡排序 */
for( int
i=0; i<arrInt.length-1;
i++ ){

for(
int j=1; j<arrInt.length;
j++ ){

if(
arrInt[j-1] < arrInt[j] ){

arrInt[j-1] =
arrInt[j] + arrInt[j-1];
arrInt[j]   =
arrInt[j-1] - arrInt[j];
arrInt[j-1] =
arrInt[j-1] - arrInt[j];
}
}
}

System.out.println("\n\n\n");
for( int
i=0; i< arrInt.length;
i++ ){

System.out.print("   "+arrInt[i]);
}

System.out.println(
"\n\n\n" );
/* 数组二分法查找 */
int first = 0;
int
last = arrInt.length;
int value = 3;
while (
first <= last ){ 
/* 如果是等于，那么表示是最后一个元素，最后一次查找 */

int
middle = (first + last)/ 2;
System.out.println(
"middle: "+middle+"   value:"+arrInt[middle] );
if(
arrInt[middle] >
value ){ /* value在 first~middle范围内 */

first =
middle-1;

}else
if( arrInt[middle] <
value ){ /* value在middle~last范围内 */

last =
middle+1;
}
else {

System.out.println(
"查找到了: "+arrInt[middle] );
break;
}
}

/* 数组翻转 */
int f = 0;
int l  =
arrInt.length-1;
while( f<l ){

arrInt[f] +=
arrInt[l];
arrInt[l] = 
arrInt[f] - arrInt[l];
arrInt[f] =
arrInt[f]  - arrInt[l];
f++;
l--;
}
System.out.println("\n\n\n");
for( int
i=0; i< arrInt.length;
i++ ){

System.out.print("   "+arrInt[i]);
}

/* Arrays的使用
* 
*  遍历: toString()   将数组的元素以字符串的形式返回；
*  排序: sort()       将数组按照升序排列；
*  查找: binarySearch()  在制定数组中查找指定元素，返回元素的索引，如果没有找到返回(返回-1)；
*     使用查找的功能的时候，数组一定要先排序;
*  */
System.out.println("\n\n");
String s =  Arrays.toString(
arrInt );
arrInt[0] = 20;
Arrays.sort(arrInt);

System.out.println(
s );
System.out.println( Arrays.toString(arrInt) );

  }

}