java循环语句,一维数组

一、while循环和do…while循环

whlie(条件语句) { 
	循环体
}//先进行条件语句的判断,再进行循环体
do { 
	循环体
}whlie (条件语句)//先执行一次循环后再进行条件语句的判断

二、break语句和continue语句

1.break语句:结束全部循环,具体应用如下:
//1+2+3+...+n<1000,求n
//此题可以利用break语句在和大于1000时结束循环,输出n的值
public static void deal() { 
        int sum = 0;
        int i = 1;
        for (; ; i++) { 
            sum = sum + i;
            if (sum > 1000) { 
                break;//当和大于1000时,利用break语句跳出循环
            }
        }
        System.out.println(i);
    }
2.continue语句:结束本次循环,具体应用如下:
//求100以内即能被3整除又能被5整除的数
//利用continue语句在判断到该数时,结束本次循环并输出该数
public static void deal1(int n) { 
        for (int i = 1; i <= n; i++) { 
            if (i % 15 != 0) { 
                continue;//如果该数不能被3和5整除,结束此次循环,进行下次循环
            }
            System.out.println(i);
        }
    }

三、一维数组

1.一维数组的定义方式:
int[] array1 = new int[3];//声明创建一个包含3个元素的数组array1(初始值为0)

int[] array2 = { 1, 2, 3};//声明、创建并初始化一个包含3个元素的数组

int[] array3 = new int[] { 1, 2, 3};//声明、创建并初始化一个包含3个元素的整型数组

int[] array4;
array[4] = { 1, 2, 3}//先声明一个数组array,再进行创建及初始化

int[] array5 = new int[3];
array5[0] = 1;
array5[1] = 2;
array5[2] = 3;//先声明、创建一个具有3个元素的数组,再用赋值语句进行初始化

2.利用一维数组输出斐波那契数列的前20项
public static void fib(int[] array) { 
        array[0] = 1;
        array[1] = 1;
        for (int i = 2; i < array.length; i++) { 
            array[i] = array[i - 1] + array[i - 2];
        }
        System.out.println(Arrays.toString(array));
}//记得在主函数中创建array数组

四、题目练习

1.实现二分查找算法:有序的数组
public class TestDemo1 { 
    public static int binary(int[] array, int key) { //key为要查找的数
        Arrays.sort(array);//正序排列数组
        System.out.println("由从小到大顺序排列数组:" + Arrays.toString(array));
        int left = 0;
        int right = array.length - 1;//将数组最小下标与最大下标分别赋值给left和right
        int mid = 0;//将中值初始化
        while (left <= right) { //“=”条件防止当输入的值为数组最大下标指向的数时,不进入循环,而返回-1的情况
            mid = (left + right) / 2;//二分法原理为折半查找,故中间值为左右下标之和除以2
            if (key == array[mid]) { //如果第一次中间下标指向的值正好等于要查找的值,返回该下标
                return mid;
            } else if (key > array[mid]) { //如果如果输入的值大于中间下标指向的值,则将当前中值下标作为下一次循环的左下标
                left = mid + 1;/*“+1”的含义:防止输入的值为数组最大下标指向的值,当进行二分查找最后一步时,因为mid为int类型,所以会导 致左边下标不在发生变化,所以要+1;当+1时,左边下标变为上一次中值下标的后一位,不影响此方法的正确性,还可以减少计算步骤*/
            } else { //只剩下输入的数下标小于中值下标的情况,将当前中值下标作为下次循环的右下标
                right = mid - 1;//与“+1”含义类似,防止输入的数对应的为最右下标
            }
        }
        return -1;//在数组中找不到输入的数,返回-1
    }
    
    public static void main(String[] args) { 
        int[] array = { 22, 15, -46, 35, 69, 20};
        System.out.println("请输入你想查找的数字:");
        Scanner scanner = new Scanner(System.in);
        int key = scanner.nextInt();
        System.out.println(binary(array, key));
     
    }
}
2.求连续子数组的最大和
public class TestDemo1 { 
public static void sumArray(int[] array) { 
        int sum = array[0];//对数组求和的变量
        int max = array[0];//求和最大值的变量
        for (int i = 1; i < array.length; i++) { //从第一项开始循环
            if (sum + array[i] < array[i]) { //如果前几项的和与本项之和小于本项,则最大连续子数组的和肯定不包括前几项
                sum = array[i];//将本项的值赋给sum,之后的循环求和从本项依次向后相加
            } else { 
                sum = sum + array[i];//如果前几项的和与本项之和大于本项,则继续向后执行递加操作
            }
            if (sum >= max) { //每次相加之后与初始的max值相比较,如果和大于max的值,则更新max,最后返回的max值即为最大连续子数列的和
                max = sum;
            }
        }
        System.out.println("连续子数组最大和为:" + max);
    }
     public static void main(String[] args) { 
        int[] array = { 1, -2, 3, 10, -4, 7, 2, -5};
        sumArray(array);
            }
}
3.交换两个数
public class TestDemo1 { 

	public static void swap(int a,int b) { 
		int tmp = 0;
		tmp = a;
		a = b;
		b = tmp;        
}
    
	public static void main(String[] args) { 
		int a = 10;
		int b = 20;
		swap(a,b);
		System.out.println(a);
		System.out.println(b);   
    }
}

用上面写的方法在执行交换两个数操作数会出现错误,原因:
在主函数中swap(a,b)操作实际是将实参a,b的地址拷贝到swap方法中,即传址。在swap方法中进行数值交换操作时只是交换了该方法中形参的地址,而原本实参的地址并没有改变,所以输出的a,b值没有发生改变。

Java中的基本元素不支持传址,必须是对象或者数组才能传址
可作如下修改:

class MyVlue { 
    int data;
}
public class TestDemo1 { 
    public static void swap(MyVlue myVlue,MyVlue myVlue2) { 
        int tmp = myVlue.data;
        myVlue.data = myVlue2.data;
        myVlue2.data = tmp;
    }       
    public static void main(String[] args) {       
        MyVlue myVlue = new MyVlue();
        myVlue.data = 10;
        MyVlue myVlue2 = new MyVlue();
        myVlue2.data = 20;
        swap(myVlue,myVlue2);
        System.out.println(myVlue.data);
        System.out.println(myVlue2.data);        
    }
}
//新建对象进行数值的交换,交换的是实参
4.逆置数组
public class TestDemo1 {  
    public static void invertArray(int[] array) { 
        System.out.println("输出该数组:" + Arrays.toString(array));
        for (int front = 0, end = array.length - 1; front < end; front++, end--) { //循环将数组下标由第一项递增,最后一项递减,当递增的下标超过递减的下标时,结束循环
            int temp = array[front];//将数组的第一个元素临时赋值给变量temp
            array[front] = array[end];//将数组最后的元素赋值到数组的第一个元素
            array[end] = temp;//将temp的值赋给数组最后的元素,实现数组下标不变,但元素的值进行倒置的操作
        }
        System.out.println("将该数组倒置后输出:" + Arrays.toString(array));
    }

    public static void main(String[] args) { 
        int[] array = { 1, 2, 3, 4, 5};
        invertArray(array);
    }
}

    原文作者:Allen..
    原文地址: https://blog.csdn.net/weixin_43289802/article/details/83073979
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞