疯狂java第四章——流程控制与数组、array

最新推荐文章于 2021-10-09 11:00:37 发布

谜的博客

最新推荐文章于 2021-10-09 11:00:37 发布

阅读量163

点赞数

分类专栏：疯狂java

本文链接：https://blog.csdn.net/m0_37635487/article/details/98967235

版权

疯狂java 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

一、顺序结构

二、分支结构

if.....else....

switch(<表达式>） // 此处的表达式可以是byte、short、char、int、String（Java7）、枚举

{

case 值1: ....... break;

case 值2：........ break;

case 值3：....... break;

default: //

}

三、循环结构

(1) while(<逻辑表达式>)

{

// 循环体

}

(2) do

｛

// 循环体

}while(<逻辑表达式>);

(3) for(初始化语句; 逻辑表达式 ; 迭代语句)

{

// 循环体

}

四、控制循环结构

1、break：（1）跳出一个循环。直接调到循环体的后一条代码。

（2）如果在break后添加标签，可以直接跳出标签代表的循环。

public static void main(String[] args)
{
 // 外层循环，outer作为标识符
 outer:
 for (int i = 0 ; i < 5 ; i++ )
 {
 // 内层循环
 for (int j = 0; j < 3 ; j++ )
 {
 System.out.println("i的值为:" + i + " j的值为:" + j);
if (j == 1)
{
// 跳出outer标签所标识的循环。
break outer;
}
 }
 }
 }

2、continue:(1)忽略本次循环剩下的语句、重新开始下一次循环。

(2)如果在continue后添加标签，可以直接忽略标签所代表循环的剩下语句。

public static void main(String[] args)
 {
 // 外层循环
 outer:
 for (int i = 0 ; i < 5 ; i++ )
 {
 // 内层循环
 for (int j = 0; j < 3 ; j++ )
 {
 System.out.println("i的值为:" + i + " j的值为:" + j);
 if (j == 1)
 {
 // 忽略outer标签所指定的循环中本次循环所剩下语句。
 continue outer;
 }
 }
 }
 }

3、 return - 可用于结束一个方法。

五、数组

数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量。

定义数组

int[] 变量名；

String[] 变量名；

数组类型的变量，只是一个引用变量。定义数组变量，仅仅只是定义了一个指针，还未指向任何内存，所以也没有空间来存储元素，所以不能使用，要初始化后才可以，

数组初始化（为数组元素分配空间）

1、静态：

元素类型数组名 = {元素1，元素2...};

元素类型数组名 = new 元素类型[]{元素1，元素2...};

（1）. 程序员不指定长度。

（2）. 只列出元素的值；由系统来动态判断数组的长度。

2、动态：

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

（1）. 程序员只指定长度。

（2）. 不给出数组元素的值，而是由系统地为每个元素分配元素值。

系统为数组元素分配值的规则为：

（1）. 所有整型，初始值都为0；

（2）. 所有浮点型，初始值都是0.0

（3）所有字符型，初始值都是'\u0000'

（4）. boolean型，初始值是false

（5）. 所有引用类型，初始值都是null

使用数组

1. 数组有一个length属性，用于返回该数组的长度。

2. 每个数组元素，相当于一个类型为数组类型去掉【一组】【方括号】的变量。

可通过数组变量[索引] 可代表数组元素，功能上相当于变量。

public class TestArray {
public static void main(String[] args) {
double[] arr = {1.5, 2.5, 3.5, 3.5, 5.5};
// 打印所有数组元素
for (double element: arr) {
System.out.println(element);
}
}
}

使用数组中两个常见的错误：

- 如果使用数组元素时，指定的索引值大于或等于length，将会引发ArrayIndexOutOfBoundsException。

- 当数组变量并未真正指向有效的数组时，，无论访问数组长度、还是访问数组元素时，都将引发NullPointException

foreach循环

for(数组|集合【元素】的类型变量 : 数组变量|集合变量)

{

// 在该循环体内，上面的变量将会依次等于每个数组元素的值。

}

foreach循环遍历数组时，一个最大的限制是：【在foreach循环中对数组元素赋值没有任何意义。】

循环变量是一个临时变量，赋值并不能改变数组的值。

六、深入数组

内存中的数组

【Java程序，必须使用java虚拟机JVM才能运行】

Java内存可分为：

-栈内存：会随着方法栈内存的结束自动销毁。

每次方法运行分配的一块临时的、很小的内存区

在方法中声明的变量，只在方法体内有效，都被称为局部（local）变量，局部变量被放在相应的方法栈内存中

-堆内存：JVM在运行时分配一块总是存在内存区，JVM退出（java命令结束时），才会销毁堆内存，一个JVM，只持有一块堆内存。所有由new新建出来的对象，统一放在“堆”内存中。

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

定义二维数组：int[][] b；

初始化：b=new int[length][]；int[][] b=new int[3][4];

String[][] str1=new String[][]{new String[3],new String[]{"hello"}};

String[][] str2={new String[3],new String[]{"hello"}};

int score[][] = {{ 67, 61 }, { 78, 89, 83 }, { 99, 100, 98, 66, 95 }};

七、数组工具类：Arrays

需要导入java.util.Arrays

➢int binarySearch(ype[] a, type key): 使用二分法查询key元素值在a数组不包含key元素值，则返回负数。调用该方法时要求数组中元素数组中出现的系5 a已经按升序排列，这样才
能得到正确结果。
➢int binarySearch(type[] a,, int fomindx, int ondx type key):这个方法与前一个方法类似，但它只搜索a数组中fromIndx到toIndex索引的元素。调用该方法时要求数组中元素已经按升序排列，这样才能得到正确结果。
➢type[] copyOf(type[] original, int length): 这个方法将会把original数组复制成一个新数组，其中length是新数组的长度如果lengh 小于oial 数组的长度，则新数组就是原数组的前面ngh个元素;如果lengh大于original 数组的长度，则新数组的前面元素就是原数组的所有元素，后面补充0 (数值类型)、false (布尔类型)或者null (引用类型)。
➢type[] copyOfRange(type[] original, int from, int to):这个方法与前面方法相似，但这个方法只复
制original数组的from索引到to索引的元素。
> boolean equals(type[] a, type[] a2): 如果a数组和a2数组的长度相等，而且a数组和a2数组的数
组元素也一一相同，该方法将返回true。
➢void fill(type[] a, type val):该方法将会把a数组的所有元素都赋值为val.
➢void fill(type[] a, int fromIndex, int toIndex, type val):该方法与前一个方法的作用相同，区别只是该方法仅仅将a数组的fromIndex到toIndex索引的数组元素赋值为val.

➢void sort(type[] a);该方法对a数组的数组元素进行排序。
➢Void sort(type[] a, int fromIndex, int tondex):该方法与前一个方法相似，区别是该方法仅仅对fromIndex到toIndex索引的元素进行排序。
➢Sting toString(type[] a):该方法将一个数组转换成一个字符串.该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号(,) 和空格隔开。

➢void parallelPrefix（xxx[] array, XxxBinaryOperator op)该方法使用op参数指定的计算公式计算得到的结果作为新的元素。op计算公式包括left、 right 两个形参其中left代表数组中前一个索引处的元素，right代表数组中当前索引处的元素，当计算第一个新数组元素时，left的值默认为1
➢void parallelPrefix（xxx[] array, int fromIndex, int toIndex, XxxBinaryOperator op)方法相似，区别是该方法仅重新计算fromIndex到toIndex索引的元素。
➢void setAlI (xxx[]array,IntIoXxxFuntion generator)该方法使用指定的生成器(generator)为所有数组元素设置值，该生成器控制数组元素的值的生成算法。

➢void parallelSetAll(xxx[] array, IntToXxxFunction generator):该方法的功能与上一个方法相同，只是该方法增加了并行能力，可以利用多CPU并行来提高性能。
➢ void parallSort（xxx[] a):该方法的功能与Arrays类以前就有的sort()类似只是该方法加了并行能力，可以利用多CPU并行来提高性能。
➢void arlelsot(xxx a, int fomIndex, int toIndex): 该方法与上一个方法相似，区别是该方法对fromIndex到toIndex索引的元素进行排序。
➢Spliterator.OfXxx spliterator(xxx[] array):将该数组的所有元素转换成对应的Spliterator对象
➢Spliterator.OfXxx spliterator(xx[] array, int startInclusive, int endExclusive): 该方法与上一一个方法相似，区别是该方法仅转换startInclusive到endExclusive索引的元素。
➢ XxxStream sream（xxx[] aray): 该方法将数组转换为Stream, Stream是Java 8新增的流式编程的API。
➢XxxStream stream(xxx[] array, int startInclusive, int endExclusive):该方法与上一个方法相似，区别是该方法仅将fromIndex到toIndex索引的元素转换为Stream.

方法相似，
该方法与上一一个
只是该方法增
区别是该方法仅

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.从array中创建arraylist；

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

4.数组中是否包含某一个值；

String a="马超";

String[] array1={"马超","马云","关羽","刘备","张飞"};

if (Arrays.asList(array1).contains(a)) {

System.out.println("马超在这里");

}

5.将数组转成set集合；

String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};

Set<String> set=new HashSet<String>(Arrays.asList(array2));

System.out.println(set);

6.将数组转成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);

7.去重复；

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));

public class ArraysTest
{
   public static void main(String[] args)
   {
       // 定义一个a数组
       int[] a = new int[]{3, 4 , 5, 6};
       // 定义一个a2数组
       int[] a2 = new int[]{3, 4 , 5, 6};
       // a数组和a2数组的长度相等，每个元素依次相等，将输出true
       System.out.println("a数组和a2数组是否相等："
           + Arrays.equals(a , a2));
       // 通过复制a数组，生成一个新的b数组
       int[] b = Arrays.copyOf(a, 6);
       System.out.println("a数组和b数组是否相等："
           + Arrays.equals(a , b));
       // 输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]
       System.out.println("b数组的元素为："
           + Arrays.toString(b));
       // 将b数组的第3个元素（包括）到第5个元素（不包括）赋为1
       Arrays.fill(b , 2, 4 , 1);
       // 输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]
       System.out.println("b数组的元素为："
           + Arrays.toString(b));
       // 对b数组进行排序
       Arrays.sort(b);
       // 输出b数组的元素，将输出[0, 0, 1, 1, 3, 4]
       System.out.println("b数组的元素为："
           + Arrays.toString(b));
   }
}

import java.util.Arrays;
/**
* Description:
* 网站: <a href="http://www.crazyit.org">疯狂Java联盟</a> 
* Copyright (C), 2001-2018, Yeeku.H.Lee 
* This program is protected by copyright laws. 
* Program Name: 
* Date: 
* @author Yeeku.H.Lee kongyeeku@163 .com
* @version 1.0
*/
public class Num2Rmb
{
 private String[] hanArr = {"零" , "壹" , "贰" , "叁" , "肆" ,
 "伍" , "陆" , "柒" , "捌" , "玖"};
 private String[] unitArr = {"十" , "百" , "千"};

   /**
   * 把一个浮点数分解成整数部分和小数部分字符串
   * @param num 需要被分解的浮点数
   * @return 分解出来的整数部分和小数部分。第一个数组元素是整数部分，第二个数组元素是小数部分。
   */
   private String[] divide(double num)
   {
       // 将一个浮点数强制类型转换为long，即得到它的整数部分
       long zheng = (long)num;
       // 浮点数减去整数部分，得到小数部分，小数部分乘以100后再取整得到2位小数
       long xiao = Math.round((num - zheng) * 100);
       // 下面用了2种方法把整数转换为字符串
       return new String[]{zheng + "", String.valueOf(xiao)};
   }

/**
 * 把一个四位的数字字符串变成汉字字符串
 * @param numStr 需要被转换的四位的数字字符串
 * @return 四位的数字字符串被转换成的汉字字符串。
 */
 private String toHanStr(String numStr)
 {
 String result = "";
 int numLen = numStr.length();
 // 依次遍历数字字符串的每一位数字
 for (int i = 0 ; i < numLen ; i++ )
 {
 // 把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48
 // 因此把char型数字减去48得到int型数字，例如'4'被转换成4。
 int num = numStr.charAt(i) - 48;
 // 如果不是最后一位数字，而且数字不是零，则需要添加单位（千、百、十）
 if ( i != numLen - 1 && num != 0)
 {
 result += hanArr[num] + unitArr[numLen - 2 - i];
 }
 // 否则不要添加单位
 else
 {
 result += hanArr[num];
 }
 }
 return result;
 }

public static void main(String[] args)
{
       Num2Rmb nr = new Num2Rmb();
       // 测试把一个浮点数分解成整数部分和小数部分
       System.out.println(Arrays.toString(nr.divide(236711125.123)));
       // 测试把一个四位的数字字符串变成汉字字符串
       System.out.println(nr.toHanStr("609"));
}
}