Java之数组,循环

break和continue的使用范围:

continue只能用于循环结构,也就是说只要有continue,肯定存在循环.

break用在switch语句和循环结构中.

break和continue单独存在时,下面不可以有任何语句,因为执行不到(会报错)

函数重载(overload)

同一个类中允许存在一个以上的同名函数,只要它们的 参数类型/参数个数/参数类型顺序 不同,跟 返回类型 无关.

Java中的数组:

首先了解下:

在函数中定义的一些 基本类型的变量(short,int,char,long,double,byte,boolean,float),和 对象的引用变量(int[ ] x等) 都是在函数的栈内存中分配,

当在一段代码块(也就是一堆花括号{ }之间)定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量

所分配的内存空间,该内存空间可以立即被另作他用.

堆内存用来存放由 new创建的对象和数组  ,在堆中分配内存,由JVM的自动垃圾回收器来管理.在堆中产生了一个数组或对象后,还可以在栈中定义一个特殊

的变量,让栈中的这个变量的取值 等于 数组 或 对象在堆内存中的首地址,栈中的这个变量就成了数组或对象的引用变量,以后就可以在程序中使用栈中的引用

变量来访问堆中的数组或对象,引用变量相当于是为数组或对象起的一个名称(叫代号也行).

引用变量是普通的变量,定义时在栈中分配,引用变量在程序运行到其作用域之外后被释放.

而数组和对象本身在 堆 中 分配,即使程序运行到使用new产生数组和对象的语句所在的代码块之外,数组和对象本身占据的内存不会被释放,数组和对象在没有引用

变量指向它时,才会变为垃圾,不能再被使用,但仍然占据内存空间不放,在随后一个不确定的时间被 垃圾回收器 收走(释放掉).这也是Java比较占内存的原因.

以上摘自张孝祥老师的<Java就业培训教程>

举例:

int[ ]  x;//定义了一个数组x,这条语句的执行完后的内存状态如下

x=new int [3];//数组初始化,内存状态如下

然后测试一下各种类型数组的默认值:

class ArrayTest
{
	public static void main(String[] args)
	{
		//int,double,float,char型数组默认值
		 int[] n=new int[3];
		  System.out.println("int "+n[1]);//0
		 char[] c=new char[3];
		   System.out.println("char "+c[1]);//ASCII码为0的空字符:‘\0‘
		 float[] f=new float[3];
		   System.out.println("float "+f[1]);//0.0f(加f为了说明是float型)
		 double[] d=new double[3];
		   System.out.println("double "+d[1]);//0.0
		 boolean[] b=new boolean[3];
		   System.out.println("boolean "+b[1]);//false
	}
}

运行结果:

两个经典的排序冒泡和选择:

示例:

import java.util.*;
class sort
{
	/*
	 冒泡排序:(从小到大,从零趟开始为了操作方便)
	 算法思想:
	  相邻两个数比较,两两比较得到的较大数不断后移,
	  最终每趟最大沉底.
	  示例:下标 0 1 2 3 4
	       i   5 3 7 9 1 

	            3 5 7 9 1 5>3交换
	  第零趟:   3 5 7 9 1 5<7不动
                    3 5 7 9 1 7<9不动
	            3 5 7 1 9 9>1交换-->9为最大,arr[4]为9
	     共比较4(arr.length-0(趟数)-1)次
	  第一趟:   3 5 7 1   -->9不用在参与比较
	             3 5 7 1   3<5不动
		     3 5 7 1   5<7不动
		     3 5 1 7   7>1交换-->7为次大,arr[3]为7
	     共比较3(arr.length-1-1)次
	  第二趟:   3 5 1     -->7不用再参与比较
	             3 5 1     3<5不动
	             3 1 5     5>1交换-->arr[2]为5
	     共比较2(arr.length-2-1)次
	  第三趟:    3 1       -->5不用再参与比较
	             1 3       3>1交换-->arr[1]为3
				 共比较1(arr.length-3-1)次
	  共走了4(arr.length-1)趟
	  最后一定剩余一个数字1,不用再参与比较,肯定最小
	*/
   //交换
   public static void swap(int[] b,int i,int j)
	{
         int temp=b[i];
         b[i]=b[j];
         b[j]=temp;
      }
   //冒泡排序
   public static void bubbleSort(int[] a)
   {
     for(int i=0;i<a.length-1;++i)//控制趟数
      for(int j=0;j<a.length-i-1;++j)//控制每趟比较的次数
	    if(a[j]>a[j+1])
	      swap(a,j,j+1);
   }
 /*
  选择排序:(从小到大)
  算法思想:
    每一趟从待排序的数据元素中选出最小(或最大)的一个元素,
    顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
   示例:下标 0 1 2 3 4
	     5 3 7 9 1
       i
            3 5 7 9 1  5>3交换
   第零趟:   3 5 7 9 1  3<7不动
              3 5 7 9 1  3<9不动
              1 5 7 9 3  3>1交换-->此时arr[0]为1,并且最小
        共比较4(arr.length-0-1)次

                5 7 9 3  5<7不动
   第一趟:     5 7 9 3  5<9不动
                3 7 9 5  3<5交换-->此时arr[1]为3,次小
        共比较3(arr.length-1-1)次

   第二趟:       7 9 5  7<9不动
                  5 9 7  5<7交换-->此时arr[2]为5.
       共比较2(arr.length-2-1)次

   第三趟:         7 9  9>7交换-->此时arr[3]为7.
      共比较1(arr.length-3-1)次

    共走了4(arr.length-1)趟,最后剩余一个9,为最大,arr[4]为9
   */
   //选择排序
    public static void selectSort(int[] b)
	{
	  for(int i=0;i<b.length-1;++i)//控制趟数
	     for(int j=i+1;j<b.length;++j)//共比较(arr.length-1)-(i+1)+1
	        if(b[i]>b[j])                //即arr.length-i-1
	          swap(b,i,j);
	}
   //选择排序第二种写法:
    public static void selectSort_2(int[] c)
    {
	   int k=0;
	   for(int i=0;i<c.length-1;++i)
		{
	        k=i;
	        for(int j=i+1;j<c.length;++j)
	         if(c[k]>c[j])
	        k=j;
	       if(k!=i)
	       swap(c,k,i);
	      }
    }
	/*
	这种写法和上面最大区别是:
	  k中每次存放较小元素的下标,直到一趟走完
	  此时k中存放这一趟最小元素下标
	  这时在和第i个位置的元素交换
	 */

   //打印数组
    public static void showArray(int[] arr)
	{
	 System.out.print("[");
	 for(int i=0;i<arr.length;++i)
	    if(i!=arr.length-1)
		  System.out.print(arr[i]+",");
         else
		System.out.println(arr[i]+"]");
    }
	//Test
    public static void main(String[] args)
	{
		int[] arr={7,3,9,11,1,6,5};
		int[] arr_2={6,2,3,1,11};
		int[] arr_3={9,8,10,2,11,3};
		bubbleSort(arr);
		System.out.println("bubbleSort: ");
		showArray(arr);

		selectSort(arr_2);
		System.out.println("slectSort: ");
	       showArray(arr_2);

	    selectSort(arr_3);
		System.out.println("selectSort_2: ");
	    showArray(arr_3);

		//Arrays.sort(arr_2);实际开发中使用
		//showArray(arr_2);
	}

}  
运行结果:

最大值与最小值:

class  MaxMin
{
 //相当于冒泡/选择排序的一趟
 //可以一次遍历同时找出最大值和最小值
   public static void main(String[] args)
   {
     int max,min;
     int[] arr={3,2,1,6,9,5};
	 max=min=arr[0];//max和min的初始值可以为数组中任何两个值,但下面的循环必须从下标0(i=0)开始
     for(int i=1;i<arr.length;++i)
       if(arr[i]>max)
	       max=arr[i];
       else
            if(arr[i]<min)
	      min=arr[i];
	 System.out.println("max="+max+",min="+min);
   }
}
运行结果:

折半(二分查找):

举例:

class BiSearch
{
 	/*
	折半(二分)查找:
	算法思想:
	  要求序列必须有序(升序/降序),因为只有这样才能确定
	  数据的范围,通过不断的折半来缩小查找数据的范围
	  设查找数据为key
	  ①通过两个变量min和max来指定数据的范围,要求min<=max
         (min=max表示只有一个数据时)
	  ②首先与mid=(min+max)/2比较,如果key=mid查找成功,直接返回
	     mid,如果key<mid,则min=mid-1,缩短查找范围,此时在让key与
		 mid=(max+min)/2比较,若key>mid,则max=mid+1,之后再与新的mid
		 比较,依次类推找到则返回,未找到则min>max.
	*/
	public static int biSearch(int[] arr,int key)
	{
	  int max=arr.length-1,min=0,mid;
	  while(max>=min)
	  {
	   mid=(max+min)/2;
	   if(key==arr[mid])
		  return mid;//返回key在数组中的下标
	   else
		 if(key<arr[mid])
           max=mid-1;
	     else
		   min=mid+1;
	  }
       return -1;//表示未找到
	 }
  public static void main(String[] args)
  {
    int[] arr={3,5,7,9,10,11};
	System.out.println("keyIndex="+biSearch(arr,11));
  }
}

折半查找过程(以上面为例)

查找成功:

示例2:

已知有序数组,要求在有序数组中插入一个元素,使之仍然有序.

class BiSearch_2
{
	//已知有序数组,要求在有序数组中插入一个元素,使之仍然有序
	/*
	 思想:
	   ①首先我们要找到该元素插入的位置,才能进行操作
	   ②由于数组有序,通过折半查找来确定其位置
	   ③把该位置(包括这个位置)的元素(从后向前)逐个后移,
	      为新插入的元素
	      空出一个位置
	*/
  public static int biSearch(int[] arr,int key)
	{
	  int max=arr.length-2,min=0,mid;
	  while(max>=min)
	  {
	   mid=(max+min)/2;
	   if(key==arr[mid])
		  return mid;//返回key在数组中的下标
	   else
		 if(key<arr[mid])
           max=mid-1;
	     else
		   min=mid+1;
	  }
      return min;//由图可知min就是该元素的插入位置
    }
   //数组中的元素后移,即赋值过程
    public static void backWard(int[] arr,int site,int key)//site为插入位置
    {
	   int i;
	   for(i=arr.length-2;i>=site;--i)//例子:site=3,arr.length=7
	      arr[i+1]=arr[i];
	   arr[i+1]=key;//此时i=2,因此插入位置为i+1
    }
  public static void main(String[] args)
  {
    int[] arr={3,5,7,9,10,11,0};//已知数组的元素为6个,最后一个0
	                           //为了让数组多开辟一个空间,存放插入元素
	int index;
	index=biSearch(arr,8);
	System.out.println("keyIndex="+index);
	backWard(arr,index,8);
	//打印
	for(int i=0;i<arr.length;++i)
	  System.out.print(arr[i]+" ");
  }
}
运行结果:

查找过程:

注意:折半查找优点是比较次数少,查找速度快,平均性能好;
其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。
进制转换:
   ①十进制转二进制(除二取余法,仅适用于正数)
class ArrayTest_2
{
  //十进制转二进制
  /*
   算法思想:
     ①利用乘2取余的方法
     ②考虑到是逆序输出可以用顺序栈(后进先出)方式输出
  */
  public static void toBi(int number)
  {
    int[] stack=new int[32];
    int top=-1;//栈顶指针(类似指针功能)
	while(number!=0)
	{
	  stack[++top]=number%2;
	  number/=2;
	}
    while(top!=-1)//出栈
	 System.out.print(stack[top--]);
  }
  //法二,利用java中提供的方法
   public static void toBi_2(int number)
  {
     StringBuffer sb=new StringBuffer();//定义了一个存数据的容器
     while(number!=0)
	{
	  sb.append(number%2);//向容器中添加
	  number/=2;
	}
	System.out.print(sb.reverse());//通过StringBuffer中的reverse功能
					   //逆序输出
  }

  public static void  main(String[] args)
  {
    toBi(20);
    System.out.println();
    toBi_2(20);
  }
  /*
   该方法只能计算正数
  */
}

②十进制转十六进制(利用移位和按位与)
     
class ToHex
{
 //十进制-->十六进制
 /*
   算法思想:
     ①首先该数与低四位为1,其余位为0(15)数相与(&)可得到该数低四位
	 ②使该数右移(>>>)四位,在与15相与又得到四位,依此类推
        知道原数变为0停止
	注意:这里用>>>而不用>>原因是考虑到负数会一直补1,
	      当然可以通过-1(补码全为1)来决定结束,但无法输出
		  符号位的十六进制,而>>>可以把负数的符号位也转成
		  十六进制
 */
  public static void toHex(int number)
  {
     StringBuffer sb=new StringBuffer();//定义了一个存数据的容器
	 int Hex;
     while(number!=0)
	 //for(int i=0;i<8;++i)//强制把32位都转换:200->0000C8
	{                    //而while则为:C8
	  Hex=number&15;
	  if(Hex>=10)
		sb.append((char)(Hex-10+‘A‘));
	  else
		 sb.append(Hex);
	  number >>>= 4;
	}
	System.out.print(sb.reverse());
  }

  public static void  main(String[] args)
  {
    toHex(-200);
	System.out.println("\n"+Integer.toHexString(-200));
  }
}

 
③十进制转R进制(查表法)
class Convert
{
 //查表法将十进制转换成R(二,八,十六)进制
 /*
 数组下标:    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
             0 1 2 3 4 5 6 7 8 9  A  B  C  D  E  F
 包括二进制,八进制,十六进制值恰好对应了数组的下标.
 */
  //二进制
  public static void toOct(int number)
   {
      trans(number,1,1);
   }
 //八进制
   public static void toBi(int number)
   {
      trans(number,7,3);
   }
   //十六进制
   public static void toHex(int number)
   {
      trans(number,15,4);
   }
  public static void trans(int number,int and,int offset)//分别接收原数,需要与的值,
								//需要移位的值
	{
      if(number==0)//为0下面不在执行
	  {
	    System.out.println(0);
		return;
	  }
	  char[] table={‘0‘,‘1‘,‘2‘,‘3‘,
			  ‘4‘,‘5‘,‘6‘,‘7‘,
			  ‘8‘,‘9‘,‘A‘,‘B‘,
			  ‘C‘,‘D‘,‘E‘,‘F‘};
	  char[] stack=new char[32];
	  int top=-1;
	  while(number!=0)
		{
	      stack[++top]=table[number & and];
	      number >>>= offset;
	    }
	  while(top!=-1)
	    System.out.print(stack[top--]);
	  System.out.println();
	}
   public static void main(String[] args)
   {
      toBi(-80);
      toHex(-80);
      toOct(-80);
   }
}
   

二维数组:
在Java中并没有真正的多维数组,只有数组的数组,虽然在应用上很像
 C语言中的多维数组,但还是有区别的.在C语言中定义一个二维数组,必须
 是一个x*y的二维矩阵块.
 而Java中的多维数组并不一定是规则的矩阵形式
定义一个多维数组:
 int[][] xx;//int xx[][],int[] xx[];
 它表示 一个数组引用变量xx,第一个元素变量为xx[0],第n个元素变量为xx[n-1].
 xx中的每个元素变量(xx[0]~xx[n-1])正好又是一个整数类型的数组引用变量.

int[ ][ ] xx;  
   xx=new int[3][ ];      
   解析:这两句代码表示数组xx有三个元素,每个元素都是int[ ]类型的一维数组.相当于定义了三个数组

引用变量,分别为:int[ ] xx[0],int[ ] xx[1],int[ ] xx[2].

由于xx[0],xx[1],xx[2]都是数组引用变量,必须对它们赋值,指向真正的数组对象.才可以引用这些数组中的

元素.

xx[0]=new int[3];

xx[1]=new int[2];

另:

二维数组的静态初始化:

int[ ][ ]  xx={{3,2,7},{1,5},{6}};

另附上 陈吉斯汗同学的关于java数组的总结,个人认为很不错:http://bdcwl.blog.163.com/blog/static/7652226520091024067604/

示例1:

class ArrayDemo1
{
    public static void main(String[] args)
    {
        int[] arr = new int[2];//建议这种方式,定义一个int型数组的引用变量 arr

        int arr[] = new int[2];

        //静态初始化
        int[] arr = new int[]{3,1};//new int[]中不能指定长度,编译不能通过
                                       //可能出现元素个数和指定长度不同

        int[] arr = {3,1};//静态初始化简化形式

        System.out.println(arr[3]);//编译可以通过,编译时期没有创建数组也就是说在运行时期才在堆内存中为数组开辟空间.
                                   //在运行时期发生数组角标越界异常
        arr=null;

        System.out.println(arr.length);//编译依然可以通过,原因同上.
                                //运行时期发生错误,arr不再引用数组,无法操作数组中的元素
                               //发出空指针异常  

       //二维数组静态初始化
         int[][]a=new int[][]{{4,2},{5,6,7}};//①
        //int[][]a={{4,2},{5,6,7}};//等价于①

  }
}

示例2:

class  DoubleArray
{
    public static void main(String[] args)
    {
        int[][] xx=new int[3][2];//二维数组中的三个元素,每个元素指向一个长度为2的一维数组
        System.out.println("x\t"+xx);//[[代表二维数组,I->Integer(整形),数组中的元素类型
                         //@后面由哈希函数算出哈希址
        System.out.println("x[0]\t"+xx[0]);

        int[][] y=new int[4][];
               System.out.println("y\t"+y);
        System.out.println("y[0]\t"+y[0]);

           int[][] x=new int[3][];//每个引用数组的长度可以不一样
                x[0]=new int[3];      //在内存中的情况如下图:
        x[1]=new int[1];
        x[2]=new int[2];

    }
}

二维数组在内存中:

时间: 2024-10-10 19:45:05

Java之数组,循环的相关文章

Java Script数组循环

<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> <script type="text/javascript" > //这里的对象数据是从今日头条源代码粘的 var obj={"has_more": false, "

java基础3_循环语句,数组

java中的循环: Java中提供了3中循环结构:  while  do-while  for ① 循环结构的作用? 可以不断重复执行循环结构中的代码: ② 上面的3个循环结构功能都是一样的,只是结构不一样: ③ 循环的次数的控制 ④ 多种循环结构的语法以及执行流程: ⑤ 能够区分每一种的特点,知道如何选择 while语法: while(条件){ // 循环体,需要重复做的事情的代码 } 执行流程: 上面的这个循环结构可能会执行n次循环 第一次  : 条件(true) ---> 执行一次循环体:

Java用数组实现循环队列

复习了下数据结构,用Java的数组实现一下循环队列. 队列的类 1 //循环队列 2 class CirQueue{ 3 private int QueueSize; 4 private int front; 5 private int rear; 6 private int[] queueList ; 7 8 public CirQueue(int QueueSize){ 9 this.QueueSize = QueueSize; 10 queueList = new int[QueueSiz

Java 螺旋数组的实现方式-一个循环实现哦

随着编程的学习和工作,感触越来越深的,就是如何做好对需求的理解.那么在学习的过程中,就是如何将一个实际问题,转化成计算机语言去实现.我觉得我的这方面的能力很是欠缺啊. 今天分享一下一个螺旋数组例子的分析: 贴上code: package excesize; /* * 螺旋数组: * 4 * 1 2 3 4 * 12 13 14 5 * 11 16 15 6 * 10 9 8 7 */ public class LuoxuanArray { public static void main(Stri

java中数组、集合、字符串之间的转换,以及用加强for循环遍历

java中数组.集合.字符串之间的转换,以及用加强for循环遍历: 1 @Test 2 public void testDemo5() { 3 ArrayList<String> list = new ArrayList<String>(); 4 list.add("甲乙1"); 5 list.add("甲乙2"); 6 list.add("甲乙3"); 7 list.add("甲乙4"); 8 //

在java 中,数组与 List&lt;T&gt; 类型的相互转换

在java中,数组与List<T> 之前进行互相转换,转换方法可总结为以下几种: 一. 将 数组转换成List<T> 1. 使用 Collections 的addAll 方法 String[] myStr = {"1","2","4","9","7"}; List<String> listStr = new ArrayList<String>(); Colle

[java基础]数组1

[java基础]数组1 1 /** 2 文件路径:G:\JavaByHands\数组 3 文件名称:ArrayTest.java 4 编写时间:2016/6/13 5 编写说明:学习数组的使用方法~~ 6 知识来源:疯狂java讲义 7 */ 8 9 /* 10 数组是用来储存多个数据的一种数据结构~~ 11 一个数据被成为一个数组元素 12 可以通过数组元素的索引来访问数组元素 13 java要求所有的数组元素具有相同的数据类型 14 一旦数组初始化完成,数组在内存中所占的空间将被固定下来,长

再学Java 之 foreach循环

从Java 5 之后,Java提供了一种新的循环:foreach循环,这种循环遍历数组和集合更加简洁. foreach循环语法格式如下: for ( type variableName : array | collection){ //variableName自动迭代访问每个元素 } 在很多书籍中,都能找到这么一句话"使用foreach循环迭代数组元素时,并不能改变数组元素".如: String books = {"a","b","c&

Java 增强 for 循环

Java 增强 for 循环 Java5 引入了一种主要用于数组的增强型 for 循环. Java 增强 for 循环语法格式如下: for(声明语句 : 表达式) { //代码句子 } 声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配.其作用域限定在循环语句块,其值与此时数组元素的值相等. 表达式:表达式是要访问的数组名,或者是返回值为数组的方法. 实例 Test.java 文件代码: public class Test { public static void main(St