文档章节

java基础二(数组)

废柴
 废柴
发布于 06/14 18:06
字数 2924
阅读 2
收藏 0
点赞 0
评论 0

一、java之数组

数组概述:

1、数组可以看成是多个相同数据类型数据的组合,对这些数据的统一管理。

2、数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。

3、数组中的元素可以是任何类型,包括基本类型和引用类型。

一维数组的声明:

1、一维数组的声明方式:

type var[];   或type[] var;

例如:

int a1[];     int[] a2;    double b[];     Person[] p1;     String s1[];

2、声明不同类型的数组

String [] arrStr;    int [] arrInt;        Double [] arrDouble

3、java语言中声明数组时不能指定其长度(数组中元素的个数),例如:

int a[5];  //非法

4、自己看

	//数组的声明
		String [] arrString;
		int [] arrInt;//不同类型的数据类型
		Double [] arrDouble;
		//声明时直接指定数组长度
		
		
		//初始化数组
		int [] arr1=new int [] {1,2,3,4,5};
		int [] arr2=new int [5];//初始化时指定数组长度为5
		arrInt=new int[] {2,2,2,2,22};//静态初始化
		
		 int[] arr3 = new int[3];        //数组定义
	        arr3[0]=1;    //数组初始化
	        arr3[1]=2;
	        arr3[2]=3;

数组对象的创建:

1、java中使用关键字new 创建数组对象,格式为:

数组名 = new 数组元素类型[数组元素个数];

例如:

public class TestArray01 {
	public static void main(String [] args)
	{
	int [] arr;//声明数组arr
	arr=new int [5];//arr初始化指定长度5
	for(int i=0;i<5;i++)
	{
		arr[i]=i;//将0到5 赋值给数组
		System.out.println(arr[i]);
				
	}
	
	}

}

2、元素为引用类型的数据(注意:元素为引用数据类型的数组中的每一个元素都需要实例化)

例如:


public class TestArray01 {
	public static void main(String [] args)
	{
		Date [] date;//声明Date的数组
		date=new Date [3];//初始化数组长度为3
			for(int i=0;i<date.length;i++)
			{
				date[i]=new Date(2018,6,14);//给数组赋值
				System.out.println(date[i].year+"年,"+date[i].month+"月,"+date[i].day+"日!");
			}
	}
	

}
class Date{//声明一个类
	int year,month,day;
	public Date(int year,int month,int day)//构造方法
	{
		this.year=year;
		this.month=month;
		this.day=day;
	}

}

 数组初始化:

1、动态初始化:

数组定义与为数组元素分配空间和赋值的操作分开进行,例如:

public class TestArray{
    public static void main(String args[]){
        int[] arr = new int[3];        //数组定义
        arr[0]=1;    //数组初始化
        arr[1]=2;
        arr[2]=3;
        
        Date[] date = new Date[3];    //数组定义
        date[0] = new Date(2014,10,25);        //数组初始化
        date[1] = new Date(2014,10,25);
        date[2] = new Date(2014,10,25);
        
    }
}
class Date{
    int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

2、多维数字静态初始化

在定义数组的同时就为数组元素分配空间并赋值,例如:

public class TestArray{
    public static void main(String args[]){
        int a[] = {1,2,3};
        Date[] date = {new Date(2014,10,25), new Date(2014,10,26), new Date(2014,10,27)};
    }
}
class Date{
    int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

数组元素的引用:

1、定义并用运算符new为之分配空间后,才可以引用数组中的每个元素,数组元素的引用方式为:

  ①、arrayName[index]

    index为数组元素下标,可以使整形常亮或整形表达式。如:

    a[3], b[i], c[6*i];

  ②、数组元素的下标从0开始;长度为n的数组的合法下标取值范围为:

    0~n-1;

2、每个数组都有一个属性lendth(注:这里length是一个属性,不是方法,没有加括号(),我们这里特别说明是为了和String的length()方法做区别)指明他的长度,例如:

  a.length的值为数组a的长度(元素个数)

  注: 

     public static void main(String args[]){}

     我们每个类中的主函数也有一个数组,名叫srgs,那么这个数组时干嘛用的呢?这个数组就好比,我们在命令行中注入 ipconfig -all 中的all. 我们可以在输入             java TestArray(类名) 23,12,aa,bbb  这个跟几个参数。然后可以在代码中输出来看到。   

  注(基础类型的包装类):

        基础类型的包转类, 基础类型是分配在栈内存中的  , 包装类是分配在堆空间里面的  。

           基础类型的包装类有:Boolean---boolean 、 Byte---byte 、 Character---char 、 Double---double  、 Float---float  、 Integer---int  、 Long---            long 、 Short---short   通常我们使用parsexxx()方法来将string类型转换为我们想要的数据类型。我们也可以使用string类型的valueOf()方法将想要的              数据类型转换为string类型。

下面我们举一个args[]参数和基础类型包装类一起使用的例子,用来计算+-x/:

 

public class TestArgs{
    public static void main(String args[]){
        if(args.length<3){
            System.out.println("error~~~");
            System.exit(0);
        }
        double  b1 = Double.parseDouble(args[0]);
        double  b2 = Double.parseDouble(args[2]);
        double  b = 0;
        if(args[1].equals("+")){
            b = b1 + b2;
        }else if(args[1].equals("-")){
            b = b1-b2;
        }else if(args[1].equals("x")){
            b = b1*b2;
        }else if(args[1].equals("/")){
            b = b1/b2;
        }else{
            System.out.println("error operation!!!");
        }
        System.out.println(b);
    }
}

 

 下面举一个用ars输入10个数,并且用选择排序,从小到大排序的示例:

 

public class TestSortInt{
    public static void main(String args[]){
        int[] a = new int[args.length];
        for(int i=0; i<args.length; i++){
            a[i] = Integer.parseInt(args[i]);
        }
        int k,temp;
        for(int i=0; i<a.length; i++){
            k = i;
            for(int j=i+1; j<a.length; j++){
                if(a[k]>a[j]){
                    k=j;
                 }
            }
            if(k!=i){
                temp = a[i];
                a[i] = a[k];
                a[k] = temp;
            }
        }
        for(int i=0; i<a.length; i++){
            System.out.print(a[i] + " ");
        }
    }
}

 

下面我们用数组里面装一个日期类型做排序的示例,用了冒泡排序。

 

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(2006,5,4);
        
        bubbleSort(date);
        
        for(int i=0; i < date.length; i++){
            System.out.println(date[i]);
        }
    }
    public static Date[] bubbleSort(Date[] a){
        int len = a.length;
        for(int i=len; i>=1; i--){
            for(int j=0; j<i-1; j++){
                if(a[j].compare(a[j+1])>0){
                    Date temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                }
            }
        }
        return a;
    }
}
class Date{
    private int year,month,day;
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    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;
    }
}

 

下面我们用数组做一个数三退一的游戏,就是说,好多人围城一圈,数1,2,3三个数,数到3的人退出,剩余的人继续重新从1开始数数,知道剩下最后一个人,我们用数组求最后一个人是谁?  

在这个示例中,我们假设有500个人手拉手围城一圈在数数,最后是下标为435这个人赢了,也就是第436个人赢了!~~~

 

public class Count3Quit{
    public static void main(String args[]){
        boolean[] arr = new boolean[500];
        for(int i=0; i<arr.length; i++){
            arr[i] = true;
        }
        
        int leftCount = arr.length;
        int count = 0;
        int index = 0;
        while(leftCount > 1){
            if(arr[index] == true){
                count++;
                if(count == 3){
                    count = 0;
                    arr[index] = false;
                    leftCount --;
                }
            }
            index ++;
            if(index == arr.length){
                index=0;
            }
        }
        
        for(int i=0; i<arr.length; i++){
            if(arr[i]==true){
                System.out.println(i);
            }
        }
    }    
}

 

 有了数组之后,我们可以设计各种各样的排序算法。然后在排好序的时候,我们又可以设计各种各样的查找算法,接下来,我们用数组实现一个简单的二分法查找算法

 

public class TestSearch{
    public static void main(String args[]){
        int[] a = {12,23,41,53,24,57,32,52,98,43,19,73};
        int postion = binarySearch(a,57);
        System.out.println(postion);
    }
    public static int binarySearch(int[] a, int searchNum){
        
        if(a.length==0)return -1;
        
        int startFlag = 0;
        int endFlag = a.length-1;
        int m = (startFlag+endFlag)/2;
        while(startFlag<=endFlag){
            if(a[m] == searchNum){
                return m;
            }else if(a[m]<searchNum){
                startFlag = m+1;
            }else if(a[m]>searchNum){
                startFlag = m+1;
            }
            m = (startFlag+endFlag)/2;
        }
        return -1;
    }
}

 

 二维数组:

  1、二维数组可以看成是以数组为元素的数组。例如:

    int a[][] = {{1,2},{3,4,5,6},{7,8,9}};

  2、java中多维数组的声明和初始化应按从高维到低维的顺序进行,例如:

    int a[][] = new int[3][];

    a[0] = new int[2];

    a[1] = new int[4];

    a[2] = new int[3];

    int t1[][] = new int[][4];//这种声明是非法的

二维数组初始化:

   1、静态初始化:

    int intA[][] = {{1,2},{2,3},{3,4,5}};

    int intB[3][2] = {{1,2},{,2,3},{4,5}};//非法声明方式

   2、动态初始化:

    int a[][] = new int[3][5];

    int b[][] = new int[3][];

      b[0] = new int[2];

      b[1] = new int[3];

      b[2] = new int[5];

二维数组举例:

  

 

public class Test{
    public static void main(String args[]){
        int a[][] = {{1,2},{3,4,5,6},{7,8,9}};
        
        for(int i=0; i<a.length; i++){
            for(int j=0; j<a[i].length; j++){
                System.out.print("["+i+"]"+"["+j+"]="+a[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

 

 二维数组举例(引用类型的二维数组):

 

public class Test{
    public static void main(String args[]){
        String s[][];
        s = new String[3][];
        s[0] = new String[2];
        s[1] = new String[3];
        s[2] = new String[2];
        
        for(int i=0; i<s.length; i++){
            for(int j=0; j<s[i].length; j++){
                s[i][j] = new String("我的位置是:"+i+","+j);
            }
            System.out.println();
        }
        for(int i=0; i<s.length; i++){
            for(int j=0; j<s[i].length; j++){
                System.out.print(s[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

 

数组的拷贝:

  1、使用java.lang.system类的静态方法

    public static void arrayCopy(object src,int srcPos,object dest,int destPos,int length){}

  2、可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的lenght个元素。

  3、如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常。

数据拷贝举例:

 

import java.lang.System;
public class TestArrayCopy{
    public static void main(String args[]){
        String[] s = {"Microsoft","IBN","Sun","Oracle","Apple"};
        String[] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        
        for(int i=0;i<sBak.length;i++){
        System.out.print(sBak[i]+" ");
        }
        System.out.println();
        
        int[][] intArray = {{1,2},{1,2,3},{3,4}};
        int[][] intArrayBak = new int[3][];
        System.arraycopy(intArray,0,intArrayBak,0,intArray.length);
        intArrayBak[2][1] = 100;
        
        for(int i=0;i<intArray.length;i++){
            for(int j=0;j<intArray[i].length;j++){
                System.out.print(intArray[i][j]+" ");
            }
            System.out.println();
        }
    }
}

Java中对Array数组的常用操作

1.声明数组;

String [] arr;
int arr1[];
String[] array=new String[5];
int score[]=new int[3];

2.初始化数组;

//静态初始化
int arr2[]=new int[]{1,2,3,4,5};
String[] array1={"马超","马云","关羽","刘备","张飞"};
String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
int score[]=new int[3];
//动态初始化
for(int i=0;i<score.length;i++)
{   
  score[i]=i+1; 
}

3.查看数组长度;

int length=array1.length;
System.out.println("length:  "+array1.length);

4.遍历数组;

r (int i = 0; i < array1.length; i++) {
    System.out.println(array1[i]);
}

5.int数组转成string数组;

int[]  array3={1,2,3,4,5,6,7,8,9,0};
        String arrStrings=Arrays.toString(array3);
        System.out.println(arrStrings);

6.从array中创建arraylist;

ArrayList<String> arrayList=new ArrayList<String>(Arrays.asList(array1));
System.out.println(arrayList);

7.数组中是否包含某一个值;

String a="马超";
String[] array1={"马超","马云","关羽","刘备","张飞"};
if (Arrays.asList(array1).contains(a)) {
    System.out.println("马超在这里");
}

8.将数组转成set集合;

String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
    Set<String> set=new HashSet<String>(Arrays.asList(array2));
    System.out.println(set);

9.将数组转成list集合;

String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
//方法 1.
List<String> list=new ArrayList<String>();
for (int i = 0; i < array2.length; i++) {
    list.add(array2[i]);
}
 
String[] arrStrings2={"1","2","3"};
//方法 2.
List<String > list2=java.util.Arrays.asList(arrStrings2);
System.out.println(list2);

10.Arrays.fill()填充数组;

int[] arr3=new int[5];
        Arrays.fill(arr3, 10);  //将数组全部填充10
               //遍历输出
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }

11.数组排序;

//方法 1.
int[] arr4 = {3, 7, 2, 1, 9};
Arrays.sort(arr4);         //.sort(int[] a)   放入数组名字
for (int i = 0; i < arr4.length; i++) {
    System.out.println(arr4[i]);
}
//方法 2.        
int[] arr5 = {3, 7, 2, 1, 9,3,45,7,8,8,3,2,65,34,5};
Arrays.sort(arr5, 1, 4);  //.sort(a, fromIndex, toIndex)    从第几个到第几个之间的进行排序
for (int i = 0; i < arr5.length; i++) {
        System.out.println(arr5[i]);
}

12.复制数组;

//方法 1.
int[] arr6 = {3, 7, 2, 1};
int[] arr7=Arrays.copyOf(arr6, 10);  //指定新数组的长度
//方法 2.        
int[] arr8=Arrays.copyOfRange(arr6, 1, 3); //只复制从索引[1]到索引[3]之间的元素(不包括索引[3]的元素)
for (int i = 0; i < arr8.length; i++) {
        System.out.println(arr8[i]);
}

13.比较两个数组;

int[] arr9 = {1, 2, 3, 4,5,6,7,8,9,0};
        boolean arr10=Arrays.equals(arr6, arr9);
        System.out.println(arr10);

14.去重复;

int[] arr11 = {1, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
//利用set的特性
Set<Integer> set2=new HashSet<Integer>();
for (int i = 0; i < arr11.length; i++) {
    set2.add(arr11[i]);
}
System.out.println(set2);
int[] arr12 = new int[set2.size()];
int j=0;
for (Integer i:set2) {
    arr12[j++]=i;
}
System.out.println(Arrays.toString(arr12));
 

15.查询数组中的最大值和最小值;

int[] arr11 = {10, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
 //计算最大值
int max = arr11[0];
for (int i = 1; i < arr11.length; i++) {
     if (arr11[i] > max) {
         max = arr11[i];
    }
  }
  System.out.println("Max is " + max);
  //计算最小值
  int min = arr11[0];
  for (int i = 0; i < arr11.length; i++) {
    if (arr11[i]<min) {
        min = arr11[i];
    }
}
  System.out.println("Min is " + min);

 

© 著作权归作者所有

共有 人打赏支持
废柴
粉丝 13
博文 66
码字总数 63566
作品 0
郑州
你所需要的java提升篇大总结

java基础篇深入解析大总结 java基础(一) 深入解析基本类型 java基础(二) 自增自减与贪心规则 java基础(三) 加强型for循环与Iterator java基础(四) java运算顺序的深入解析 java基础(五) Str...

sihailoveyan ⋅ 04/25 ⋅ 0

Android JNI(一)——NDK与JNI基础

本系列文章如下: Android JNI(一)——NDK与JNI基础 Android JNI学习(二)——实战JNI之“hello world” Android JNI学习(三)——Java与Native相互调用 Android JNI学习(四)——JNI的常用方法...

隔壁老李头 ⋅ 05/09 ⋅ 0

Android JNI学习(三)——Java与Native相互调用

本系列文章如下: Android JNI(一)——NDK与JNI基础 Android JNI学习(二)——实战JNI之“hello world” Android JNI学习(三)——Java与Native相互调用 Android JNI学习(四)——JNI的常用方法...

隔壁老李头 ⋅ 05/09 ⋅ 0

Java学习---Java简单认识

前言 小编在学习Java方面的基础知识,发现里面有很多是结合之前的语言的特点发展过来的,不同的地方是,Java有它自己的发展和特点。下面小编先简单地做一下总结,结合看过的1-2章的J2SE视频,...

m18633778874 ⋅ 04/01 ⋅ 0

Java开发每日复盘2018_0514

今天主要跟大家分享3个部分: 一、「Java的核心机制」 二、「Java命名规范」 三、「Java数据类型相关」 下面我们来一个一个的说: 「Java核心机制」 Java是一种强制面向对象的解释型语言(O...

ZeroOSTalk ⋅ 05/14 ⋅ 0

Android JNI学习(四)——JNI的常用方法的中文API

本系列文章如下: Android JNI(一)——NDK与JNI基础 Android JNI学习(二)——实战JNI之“hello world” Android JNI学习(三)——Java与Native相互调用 Android JNI学习(四)——JNI的常用方法...

隔壁老李头 ⋅ 05/09 ⋅ 0

随机模拟 java 数据插件 - Jmockdata

Jmockdata ![License](http://www.apache.o

寻觅一只耳朵 ⋅ 2017/01/05 ⋅ 20

方向选择(嵌入式 大数据 java)

嵌入式:单片机之类的 比如指纹解锁底层就是此技术,反正就是和硬件打交道。 大数据:最近很火的概念技术 有点玄玄乎乎的,前途不好定义,不过门槛也是高的,对算法之类的要求还是比较高的 ...

codingcoge ⋅ 05/03 ⋅ 0

Scala笔记整理(二):Scala数据结构—数组、map与tuple

[TOC] 数组 定长数组 如果你需要一个长度不变的数组,可以用Scala中的Array。例如: 在JVM中,Scala的Array以Java数组方式实现。示例中的数组在JVM中的类型为java.lang.String[]。Int、Doubl...

xpleaf ⋅ 04/18 ⋅ 0

Java程序员必读书单,家族又添新成员

点击关注异步图书,置顶公众号 每天与你分享IT好书 技术干货 职场知识 参与文末话题讨论,每日赠送异步图书。 ——异步小编 有些革命出其不意地吸引了全世界的眼球。Twitter、Linux操作系统和...

异步社区 ⋅ 05/09 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

浅谈springboot Web模式下的线程安全问题

我们在@RestController下,一般都是@AutoWired一些Service,由于这些Service都是单例,所以并不存在线程安全问题。 由于Controller本身是单例模式 (非线程安全的), 这意味着每个request过来,...

算法之名 ⋅ 今天 ⋅ 0

知乎Java数据结构

作者:匿名用户 链接:https://www.zhihu.com/question/35947829/answer/66113038 来源:知乎 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 感觉知乎上嘲讽题主简...

颖伙虫 ⋅ 今天 ⋅ 0

Confluence 6 恢复一个站点有关使用站点导出为备份的说明

推荐使用生产备份策略。我们推荐你针对你的生产环境中使用的 Confluence 参考 Production Backup Strategy 页面中的内容进行备份和恢复(这个需要你备份你的数据库和 home 目录)。XML 导出备...

honeymose ⋅ 今天 ⋅ 0

JavaScript零基础入门——(九)JavaScript的函数

JavaScript零基础入门——(九)JavaScript的函数 欢迎回到我们的JavaScript零基础入门,上一节课我们了解了有关JS中数组的相关知识点,不知道大家有没有自己去敲一敲,消化一下?这一节课,...

JandenMa ⋅ 今天 ⋅ 0

火狐浏览器各版本下载及插件httprequest

各版本下载地址:http://ftp.mozilla.org/pub/mozilla.org//firefox/releases/ httprequest插件截至57版本可用

xiaoge2016 ⋅ 今天 ⋅ 0

Docker系列教程28-实战:使用Docker Compose运行ELK

原文:http://www.itmuch.com/docker/28-docker-compose-in-action-elk/,转载请说明出处。 ElasticSearch【存储】 Logtash【日志聚合器】 Kibana【界面】 答案: version: '2'services: ...

周立_ITMuch ⋅ 今天 ⋅ 0

使用快嘉sdkg极速搭建接口模拟系统

在具体项目研发过程中,一旦前后端双方约定好接口,前端和app同事就会希望后台同事可以尽快提供可供对接的接口方便调试,而对后台同事来说定好接口还仅是个开始、设计流程,实现业务逻辑,编...

fastjrun ⋅ 今天 ⋅ 0

PXE/KickStart 无人值守安装

导言 作为中小公司的运维,经常会遇到一些机械式的重复工作,例如:有时公司同时上线几十甚至上百台服务器,而且需要我们在短时间内完成系统安装。 常规的办法有什么? 光盘安装系统 ===> 一...

kangvcar ⋅ 昨天 ⋅ 0

使用Puppeteer撸一个爬虫

Puppeteer是什么 puppeteer是谷歌chrome团队官方开发的一个无界面(Headless)chrome工具。Chrome Headless将成为web应用自动化测试的行业标杆。所以我们很有必要来了解一下它。所谓的无头浏...

小草先森 ⋅ 昨天 ⋅ 0

Java Done Right

* 表示难度较大或理论性较强。 ** 表示难度更大或理论性更强。 【Java语言本身】 基础语法,面向对象,顺序编程,并发编程,网络编程,泛型,注解,lambda(Java8),module(Java9),var(...

风华神使 ⋅ 昨天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部