java数组笔记

数组的声明：

一维数组的声明方式   type[] varName;    
或 type varName[];java声明数组中是不能指定其长度的，例如 int a[5];//非法

数组对象的创建：

java中使用关键字 new来创建数组对象，格式，  数组名 = new 数组元素的类型[数组元素的个数]

元素为引用数据类型的数组中的每一个元素都需要实例化

数组的初始化（静态初始化，动态初始化）动态初始化：数组定义与为数组元素分配空间和赋值的操作分开进行

例如 
int a[] ;

         a =  new int[4];

静态初始化：在定义数组的同时就为数组元素分配空间并赋值

例如：int a[] = new int[5];

数组元素的默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化

public class Count3Quit
{
//数三退一的程序
public static void main(String[] args){
//定义一个布尔型数组，里面放500个人，若都存在，则true，反之则为false
boolean[] arr = new boolean[500];
for(int i = 0;i < arr.length; i++){
arr[i] = true;
}
int leftCount = arr.length;//定义圈内剩余人数
int count = 0;//计时器，数三归0
int index = 0;//记录数数人的位置
while(leftCount > 1){
if(arr[index] == true){
count++;//数数
if(count == 3){
//当数到3的时候
arr[index]=false;//退出该人
leftCount--;//剩余人数减一
count=0;//计数器归0
}
}
index++;

//判断index是否到了500，到了500要归0
if(index==500){
index=0;
}

}
//输出留下的最后一个人，
for(int i=0;i<arr.length;i++){
if(arr[i] == true){
System.out.print(i);
}
}
}
}


public class Count3Quit2
{
public static void main(String[] args){
//定义一个500个小孩的圈
KidCircle kc = new KidCircle(500);
//定义计数器，数三退一
int countNo =0;//记数
//从第一个小孩开始数数
Kid k = kc.first;
while(kc.count>1){
countNo++;
if(countNo == 3){
countNo = 0;
kc.delete(k);
}
k = k.right;
}
System.out.println(kc.first.id);
}
}

//定义对象（小孩）
class Kid
{
int id;//定义编号
Kid left;//左边的小孩
Kid right;//右边的小孩
}

class KidCircle
{
int count = 0 ;//定义圈内有多少个小孩
Kid first, last;

//定义构造方法
KidCircle(int n){
for(int i=0;i<n;i++){
add();
}
}

//定义一个添加小孩的方法
void add(){
Kid k = new Kid();
k.id = count;
if(count <= 0){
first = k;
last = k;
k.left = k;
k.right = k;
}else{
last.right = k;//最后一个小孩的右手等于新添加进来的小孩
k.left = last;//新添加进来的小孩的左手等于最后一个小孩
k.right = first;//新添加进来的小孩的右手等于第一个小孩
first. left = k;//第一个小孩的左手等于新添加进来一个小孩
last = k;//把最后一个小孩修改为新添加进来的 小孩
}
count++;//圈内人数加一
}

void delete(Kid k){
if(count <= 0){
return ;
}else if(count == 1){
first = last = null;
}else{
k.left .right = k.right;//k左边的小孩的右手拉着k右边的小孩
k.right.left = k.left;//k右边小孩的左手拉着k左边的小孩
//如果删除的是第一个小孩
if(k == first){
first = k.right;//第一个小孩是删除小孩的右边小孩
}else if( k == last){
//如果删除的是最后一个小孩
last = k.left;
}
}

count--;
}

}

public class DateSort
{
public static void main(String[] args){
Date[] date=new Date[5];
date[0]=new Date(2006,5,4);
date[1]=new Date(2006,7,4);
date[2]=new Date(2008,5,4);
date[3]=new Date(2004,5,9);
date[4]=new Date(2004,5,4);

//用冒泡法排序
bubleSort(date);
for(int i=0;i<date.length;i++){
System.out.println(date[i]);
}
}
//定义冒泡方法
public static Date[] bubleSort(Date[] d){
int len=d.length;
for(int i =len-1;i>=1;i--){
for(int j =0;j<=i-1;j++){
if(d[j].compare(d[j+1])>0){
Date temp=d[j];
d[j]=d[j+1];
d[j+1]=temp;
}
}
}
return d;
}
}
class Date{
int year,month,day;
Date(int y,int m,int d){
year=y;
month=m;
day=d;
}
public int compare(Date date){
return year > date.year ? 1
: year < date.year ? -1
: month > date.month ? 1
: month < date.month ? -1
: day > date.day ? 1
: day < date.day ? -1 : 0;
}
public String toString(){
return "year:month:day:"+year+"-"+month+"-"+day;
}
}

//2,4,6,7,3,5,1,9,8
//程序目的：从命令行中将这些数字读入。将数字依次放入数组中，然后返回一个排序之后的数组（按升序排序）
public class SortArray{
public static void main(String[] args ){
//从命令行读入数字
int[] arr=new int[args.length];
for(int i=0;i<args.length;i++){
arr[i]=Integer.parseInt(args[i]);
}
print(arr);
//对数组进行排序
selectionSort(arr);
print(arr);
}
//定义选择排序来排序数组的大小：2 4 6 7 3 5 1 9 8 算法思想：拿2和后面的所有数据进行比较，找到3比他小，则将3调到前面来，
/* private static void selectionSort(int[] arr){
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[j]<arr[i]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}*/
private static void print(int[] a){
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
System.out.println();
}
//换一种排序算法：2 4 6 7 3 5 1 9 8 算法思想：拿2和后面所有数据进行比较，找到3比他下，然后拿3和后面的数据比较，找到比3小的数据1，将1和2调换顺序，若没有找到则将3和1调换顺序

private static void selectionSort(int[] a){
int k,temp;
for(int i=0;i<a.length;i++){
k=i;
for(int j=k+1;j<a.length;j++){
if(a[j]<a[k]){
k=j;
}
}
if(k!=i){
//交换位置
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
}
}

public class TestArray{
public static void main(String[] args){
int[] a={3,6,7,1,35,34,5,4};
/* for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}*/
if(args.length<3){
System.out.println("java TestArray \"n1\" \"op\" \"n2\"");
System.exit(-1);
}
double d1=Double.parseDouble(args[0]);
double d2=Double.parseDouble(args[2]);
double d=0;
if(args[1].equals("+")) {
d=d1+d2;
}else if(args[1].equals("-")){
d=d1-d2;
}else if(args[1].equals("x")){
d=d1*d2;
}else if(args[1].equals("/")){
d=d1/d2;
}else {
System.out.println("参数有错误");
System.exit(-1);
}
System.out.println(d);

}
}

public class TestDateSort
{
public static void main(String[] args){
Date[] date = new Date[5];
date[0] = new Date(2006,5,4);
date[1] = new Date(2006,7,4);
date[2] = new Date(2008,5,4);
date[3] = new Date(2004,5,9);
date[4] = new Date(2004,5,4);

Date d = new Date(2006,7,4);
//对date数组进行排序
bubbleSort(date);
for(int i =0; i<date.length;i++){
System.out.println(date[i].toString());
}
System.out.println(binsearch(date,d));

}

public static void bubbleSort(Date[] date){
int len = date.length;
for(int i = len-1;i>=1;i--){
for(int j = 0;j<=i-1;j++){
if(date[j].compare(date[j+1])>0){
Date temp = date[j];
date[j] = date[j+1];
date[j+1] = temp;
}
}
}
}

public static int binsearch(Date[] date,Date d){
if(date.length==0) return -1;
int startPos = 0;
int endPos = date.length-1;
int m = (startPos + endPos)/2;
while(startPos<= endPos){
if(d.compare(date[m])==0) return m;
if(d.compare(date[m])>0){
startPos = m+1;
}
if(d.compare(date[m])<0){
endPos = m-1;
}
m = (startPos+endPos)/2;
}
return -1;
}

}

class Date
{ int year,month,day;
Date(int y,int m,int d){
this.year = y;
this.month = m;
this.day = d;
}

public int compare(Date date){
return year>date.year?1
:year<date.year?-1
:month>date.month?1
:month<date.month?-1
:day>date.day?1
:day<date.day?-1:0;
}

public String toString(Date date){
return "year-month-day"+date.year+"-"+date.month+"-"+date.day;
}
}
public class TestSearch
{
public static void main(String[] args){
int a[] = {1,3,6,8,9,10,12,18,20,34};
int i = 12;
System.out.println(search(a,i));
System.out.println(binarySearch(a,i));
}

public static int search(int[] a,int num){
for(int i=0;i<a.length;i++){
if(a[i] == num){
return i;
}

}
return -1;
}

public static int binarySearch(int[] a,int num){
if(a.length ==0) return -1;
int startPos = 0;
int endPos = a.length-1;
//取中间值
int m= (startPos+endPos)/2;
//循环直到开始指针小于结束指针时停止
while(startPos<= endPos){
//如果中间位置值正好等于要找的数，返回中间数的下标值
if(num == a[m]) return m;
//如果要找的数大于中间位置的值，则在中间位置的右边找，
//将右边位置的下一个作为起始位置，重新二分，找中间数
if(num>a[m]){
startPos = m+1;
}
//如果要找的数小于中间位置的值，将结束位置减一，重新二分
if(num<a[m]){
endPos = m-1;
}
m=(startPos+endPos)/2;
}
return -1;

}
}