1.什么是数组

2.怎么使用数组

package test;

public class ShuZu {
        
    public static void main(String[] args) {
        
        /**
         * 1.什么是数组
         *         数组是具有相同数据类型的一组数据的线性集合
         *      使用new 来分配内存空间
         */
        
        //1.初始化一维数组
        int arry[]=new int[]{1,2,3,4};
        int  arry2[]={1,3,5,6};
        //数组的下标是从0开始的    
        for(int i=0;i<arry.length;i++)
        {
            System.out.println(i);
        }
        
        //2.创建二维数组
        int twoArry[][]={{1,2,3},{2,34,4}};
        //遍历二维数组的方法,先循环有几个大数组,在循环小的数组
        for(int i=0;i<twoArry.length;i++) //有两个大的数组
        {
            for(int j=0;j<twoArry[i].length;j++)//小的有3个
            {
                System.out.print(twoArry[i][j]+"  ");
            }
            System.out.println();//换行
        }
        
        int i=0;
        for(int s[]:twoArry){
            
            i++;
            int j=0;
            for(int g:s)
            {
                j++;
                if(i==twoArry.length && j==s.length)
                {
                    System.out.print(g);
                }else{
                    System.out.println(g+",");
                }
            }
        }//第二种方法结束
    
    }
}
***********************************************************************************

2.数组的常用方法

package TinkingInJava.chb0;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class ShuZu {
    /**
     * 数组中常用的方法
     * @param args
     */
    public static void main(String[] args) {
        
        int[] arry={1,3,4,5};
        
        //1.查看数组的长度
        int length=arry.length;
        System.out.println("数组的长度:"+length);
        
        //2.遍历数组
        for (int i = 0; i < arry.length; i++) {
            System.out.print(arry[i]+",");
        }
        System.out.println();
        
        //3.int数组转成string数组
         String arrStrings=Arrays.toString(arry);
         System.err.println("String 数组:"+arrStrings);
        
         //4.数组中是否包含某一个值
         String[] array1={"gg","马云","关羽","刘备","张飞"};
         if(Arrays.asList(array1).contains("gg"))
         {
             System.out.println("有 gg");
         }else
         {
             System.out.println("没有");
         }
        
         //5.将数组转成list集合
          ArrayList<String> arrayList=new ArrayList<String>(Arrays.asList(array1));
            System.out.println(arrayList);
        
         //6.将数组转成set集合
        
            String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
            Set<String> set=new HashSet<String>(Arrays.asList(array2));
            System.out.println(set);
            
          //7.将数组转成list集合
        
           List<String> list=new ArrayList<String>();
           for(int i=0;i<array2.length;i++)
           {
               //array2[i]  是得到数组里面的值,然后一个一个加入到集合里面
               list.add(array2[i]);
           }
           
           
           //8.数组排序   (里面有个经典的冒泡排序,后面介绍)
           
           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]);
           }
           System.out.println();
        
           //9.复制数组
           int[] arr9={1,2,3,555,5};
           int[] arr91=Arrays.copyOf(arr9, 10);  //指定新数组的长度
           int[] arr8=Arrays.copyOfRange(arr9, 1, 3); //只复制从索引[1]到索引[3]之间的元素(不包括索引[3]的元素)
           
           //10 比较数组
           int[] arr10 = {1, 2, 3, 4,5,6,7,8,9,0};
           int[] arr101 = {1, 2, 3, 4,5,6,7,8,9,0};
           boolean arr102=Arrays.equals(arr10, arr101);
           System.out.println(arr102);
           
           
           //11  去重复
           
           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));
             
             //12 查询数组中的最大值和最小值
             
             int[] a1={1,2,3,4};
            
            //计算数组中的最大是
            //我们先定一个最大值   然后跟其他的值,进行对比,如果比我们规定的一个数大,我们就赋值
            int max=a1[0];  //先假设a1[0]就是1 为最大值
            //遍历数组
            for(int i=0;i<a1.length;i++)
            {
                if(max<a1[i])  //如果max小于后面的数组 我们就让这个大的值 去覆盖 max这个我们一开始假设的最大值
                {
                    max=a1[i];
                }
            }
            System.out.println(max);
            
            
            //最小值也一样的道理
            int min=a1[0];  //先假设a1[0]就是1 为最大值
            //遍历数组
            for(int i=0;i<a1.length;i++)
            {
                if(min>a1[i])  //如果max大于后面的数组 我们就让这个小的值 去覆盖 min这个我们一开始假设的最小值
                {
                    min=a1[i];
                }
            }
            System.out.println(min);
             
    }

}

***********************************************************************************

3.数组的排序算法

  数组有多的算法,冒泡,直接选择,反转排序    设计这个算法的目的是为了,方便统计,查询

  1)冒泡排序

    百度下很多,图文并茂的

    冒泡排序,就是把两个挨在一起的两个数(官方说 元素)进行比较,如果满足一定的条件就进行交换,每次交换,都会将最大值或者最小值,排在后面,下次循环对数组的其他数一样的操作

    排序的过程,总是把小的往前放,大的往后放,类似水中的气泡

package TinkingInJava.chb0;

import java.util.Arrays;

public class MaoPao {
    
    public static void main(String[] args) {
        
        //创建·一个数组
        int[] a1={55,12,35,15,2,1,2,55,44};
        Arrays.sort(a1);//数组自带排序
        //创建冒泡排序的对象
        MaoPao m=new MaoPao();  //调用里面的方法
        m.sort(a1);
    }
    
    public void sort(int[] a)
    {
        
            for(int i=1;i<a.length;i++)  //先遍历所以的数组
            {
                    //比较两个相邻的元素。较大的数往后冒泡
                    for(int j=0;j<a.length-i ;j++)  //a.length-i=7   因为最后一个不用排序了
                    {
                        if(a[j]>a[j+1])   // 55 12
                        {
                            int temp=a[j]; //把第一个元素保存到临时变量中
                            a[j]=a[j+1];    //把第二个元素值保存到第一个元素中
                            a[j+1]=temp;    //把临时变量放在第二个元素中
                            
                        }            //开始
                        //没有排序前     55,12,35,15,2,1,2,55,44
                        //第1次排序      12,55,35,15,2,1,2,55,44    1
                        //第2次排序      12,35,55,15,2,1,2,55,44    2
                        //第3次排序      12,35,15,55,2,1,2,55,44    3
                        //第4次排序      12,35,15,2,55,1,2,55,44    4
                        //第5次排序      12,35,15,2,1,2,55,55,44    5
                        //第6次排序      12,35,15,2,1,2,55,55,44    6
                        //第7次排序      12,55,35,15,2,1,2,44,55// 结束   7   可以观察到 55刚好是一条斜线
                        //依次类推
                    }
            }
            show(a);
    }
    
    public void show(int[] b)
    {
        for(int i:b)
        {
            System.out.print(">"+i);
        }
    }

}

  

java基础讲解07-----数组的更多相关文章

  1. 062 01 Android 零基础入门 01 Java基础语法 07 Java二维数组 01 二维数组应用

    062 01 Android 零基础入门 01 Java基础语法 07 Java二维数组 01 二维数组应用 本文知识点:二维数组应用 二维数组的声明和创建 ? 出现空指针异常 数组的名字指向数组的第 ...

  2. Java 基础类型转换byte数组, byte数组转换基础类型

    Java 基础类型转换byte数组, byte数组转换基础类型 Java类型转换 java类对象转化为byte数组

  3. Java基础语法(7)-数组

    title: Java基础语法(7)-数组 blog: CSDN data: Java学习路线及视频 1.数组的概述 数组(Array),是多个相同类型数据按一定顺序排列的集合,并使用一个名字命名,并 ...

  4. Java基础语法(8)-数组中的常见排序算法

    title: Java基础语法(8)-数组中的常见排序算法 blog: CSDN data: Java学习路线及视频 1.基本概念 排序: 是计算机程序设计中的一项重要操作,其功能是指一个数据元素集合 ...

  5. Java基础语法(数组)

    第4天 Java基础语法 今日内容介绍 u 流程控制语句(switch) u 数组 第1章 流程控制语句 1.1 选择结构switch switch 条件语句也是一种很常用的选择语句,它和if条件语句 ...

  6. Java基础学习之数组基本属性和方法

    数组对于每一门编程语言都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同.Java语言中提供的数组是用来存储固定大小的同类型元素.你可以声明一个数组变量,如 int[100] 来代替直接 ...

  7. Java基础复习之数组

    Java基础复习之:数组 简介 数组(Array):多个相同数据类型按照一定顺序排列的集合,并使用一个名字命名,通过编号的方式对这些数据进行统一管理 一维数组 一维数组的声明与初始化 int[] id ...

  8. java基础5 (一维)数组和二维数组

    本文知识点(目录): 一维数组(一维数组的概念.优点.格式.定义.初始化.遍历.常见异常.内存分析以及常见操作(找最大值.选择排序.冒泡排序等等))    二维数组(二维数组的遍历.排序.查找.定义. ...

  9. Java基础_0306:数组的定义与使用

    数组 数组指的就是一组相关变量的集合.例如:如果说现在要想定义100个整型变量,按照传统的思路,可能这样定义: int i1,i2 ,... i100,一共写100个变量. 以上的形式的确可以满足技术 ...

  10. java基础学习总结——数组

    一.数组的基本概念 数组可以看成是多个相同类型数据组合,对这些数据的统一管理. 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量. 数组的元素可以是任何数据类型,包括基 ...

随机推荐

  1. 【二分图匹配】BZOJ1562-[NOI2009] 变换序列

    [题目大意] 对于0,1,…,N-1的N个整数,给定一个距离序列D0,D1,…,DN-1,定义一个变换序列T0,T1,…,TN-1使得每个i,Ti的环上距离等于Di.一个合法的变换序列应是0,1,…, ...

  2. MATLAB/Octave warning: mx_el_eq: automatic broadcasting operation applied 错误分析

    在进行对一个mXn的矩阵与mX1的矩阵进行==比较时,原意是想让mXn的矩阵的每一行分别与mX1的矩阵每一行进行比较,得到的结果虽然是对的,但会报一个warning: mx_el_eq: automa ...

  3. 解决myeclipse不编译的方法

    请按照下面方法对号入座: MyEclipse不编译解决1. 确保 project->build automatically 已经被选上(最基本). MyEclipse不编译解决2. 如果选上了, ...

  4. 【java】代码优化点

    1.对数据库数据的计数统计,尽量在数据库查询时候就使用count()进行统计,避免返回List到项目中统计List大小 2.对于数据库中表中字段数据过长,例如存储的是text类型而不是verchar类 ...

  5. Hibernate 注解@Column(nullable = false) 和 @Column(unique=true)

    unique=true是指这个字段的值在这张表里不能重复,所有记录值都要唯一,就像主键那样; nullable=false是这个字段在保存时必需有值,不能还是null值就调用save去保存入库;

  6. 为TextView设置两种状态,程序中可以动态切换

    经常会需要用文字的两种状态来表示当前系统的某两种状态.比如:         这里的第一个TextView和后两个TextView就表示了两种状态.我们可以在程序的动态的切换状态(而不是直接修改颜色) ...

  7. iOS:延时执行的三种方式

    延时执行的三种方式:performSelectorXXX方法.GCD中延时函数.创建定时器   第一种方式:NSObject分类当中的方法,延迟一段时间调用某一个方法 @interface NSObj ...

  8. Android视图SurfaceView的实现原理分析(示例,出错代码)

    在Android系统中,有一种特殊的视图,称为SurfaceView,它拥有独立的绘图表面,即它不与其宿主窗口共享同一个绘图表面.由于拥有独立的绘图表面,因此SurfaceView的UI就可以在一个独 ...

  9. vmware虚拟机 C硬盘空间 无损扩容 新测

    摘自: http://hi.baidu.com/y276827893/item/78a351f427726549932af214 其实上面一步的话, 虚拟机设置 里选择磁盘,实用工具里也有这个功能的. ...

  10. SQL通过身份证获取信息

    SELECT t.identity_number '身份证号',SUBSTR(t.identity_number,1,2) AS "省份",SUBSTR(t.identity_nu ...