语句与数组
1.流程控制
1.1 顺序结构
顺序结构就是一直执行下去的语句结构。就是我们前面所做的那种。
1.2 判断结构
判断结构可根据不同的判断条件执行不同的语句,判断条件就是关系表达式。
判断结构包括:if条件语句和 switch语句。
1)if语句
定义 :在某个条件成立的情况下执行某段程序,如果条件不成立,就执行另外的语句。
If 条件语句也分为:简单的if条件语句、if…else…语句和 if .. else if … 多分支语句
if (判断条件)
{
复合语句...
}
else if(判断条件)
{
复合语句...
}
...//可以有零个或多个else if语句
else//最后的else语句也可以省略
{
复合语句...
}
2) switch语句
语句特点:
1.switch语句选择的类型只有四种:byte,short,int,char(JDK 7 新增功能可以放下String类型).
2.case 之间与default 没有顺序。先执行第一个case,没有匹配的case 就执行default.
3.结束switch语句有两种情况,遇到break,执行到switch语句结束。
4.如果匹配的case 或者default没有对应的break,那么程序会继续向下执行,执行可能执行的语句,直到遇到break或者switch结尾结束。
switch(表达式){
case 常量表达式 1 : 语句序列 1 ;break; //break可有可无
case 常量表达式 2 : 语句序列 2 ;break; //break可有可无
case 常量表达式 3 : 语句序列 3 ;break; //break可有可无
.。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
case 常量表达式 n : 语句序列 n ;break; //break可有可无
default : 语句序列 n + 1 ; break; 最后的break的确可省。
}
1.3 循环结构
循环结构:通过循环语句让同一段代码反复执行多次,执行完毕程序才会继续往后运行
1)while
while语句是“当型”循环语句,也就是条件表达式成立时,执行循环体中的内容。其语法格式为:
while(条件表达式){
循环体
}
public class TestWhile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int count = 1 ;
//循环条件
while(count <= 10 ){
if(count < 10)
//循环输出1~10的数
System.out.print(count + ",");
else
System.out.print(count);
//count ++ 变量自增
count ++;
}
}
}
输出:
1,2,3,4,5,6,7,8,9,10
注:若有时循环条件难以写出,可直接在“()”填写true(所谓死循环),而后在循环体中加入判断条件,当满足条件时执行break语句就可以跳出循环。
while(true){
If (条件表达式)break;
}
2) do….while 语句
do … while先执行一次循环体,然后判断while中的表达式,如果是true继续执行,如果是false则跳出循环。
所以do …while 至少要执行循环体一次。
其语法格式为:
do{
循环体
} while(条件表达式)
3) for 语句
语法格式:
for(表达式1; 表达式2;表达式3){
语句序列
}
表达式1:该表达式用于初始化循环控制变量,它只在循环开始时执行一次。
表达式2:循环条件表达式,它的类型为boolean,如果表达式的值为true,则执行一次循环体。
表达式3:该表达式用于改变循环体变量的值。
for循环的执行过程如下:
1.执行表达式1,完成某一变量的初始化工作,如 int I = 0;
2.判断表达式2的值,如I < 100。若表达式2的值为true,则执行一次循环体,然后执行第三步,否则,退出循环体结束for循环。
3.执行表达式3,这部分通常执行循环控制变量的修改。
4. 跳转到第二步继续执行循环。
具体如下图:
4)嵌套的循环
当循环结构的循环体中又包含循环结构时,循环结构就呈嵌套的形式。三种循环语句可以相互嵌套。
代码实例:输出九九乘法表
public class TestWhile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i= 1 ; i < 10 ; i ++ ){
//输出九九乘法表的一行
for(int j = 1 ; j <= i ; j ++){
//输出九九乘法表的一小列
System.out.print(j + "*" + i + "=" + j * i + " ");
} //第一行换一行
System.out.println();
}
}
}
输出:
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
5) 循环的跳转
continue、break、return
continue:结束本次循环,继续执行下一次(只是不执行contine下面的内容)
break:结束循环
return:结束方法
其中continue 、break 是可以用标记来实现跳转的。
用九九乘法表看看标记的作用
public class TestWhile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
outer: for (int i = 1; i < 10; i++) {
for (int j = 1; j <= i; j++) {
if (i == 2)
// 中断外循环 连空行也不输出
continue outer;
if (i == 3)
// 中断内循环 这里是因为在这循环里i == 2 , 所以作用相当于break
continue;
if (i == 6)
// 跳出内循环 只是结束一层循环
break;
if (i == 8)
// 跳出外循环 跳出时循环已结束
break outer;
// 输出九九乘法表的一列
System.out.print(j + "*" + i + "=" + j * i + " ");
}
// 第一循环换一行
System.out.println();
}
}
}
输出:
1*1=1
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
4. 函数
定义:函数就是定义在类中的具有特定功能的一段独立小代码。函数也称为方法。
格式:
[访问修饰符] [静态修饰符] 返回值类型函数名(参数类型 形式参数1,参数类型 形式参数2){
执行语句
return 返回值;
}
参数说明:
返回值类型:函数运行后的结果的数据类型 ,不需要返回,返回值类型为 void 。
参数类型:是形式参数的数据类型。
实际参数:是一个变量,用于存储调用函数时传递函数的实际参数。
return: 用于结束函数。
返回值:该值会返回给调用者。
函数的特点
1. 定义函数可以将功能代码进行封装。
2. 全类对该功能的复用。
3. 函数只有被调用才会执行。
4. 函数的出现提高了代码的复用性。
5. 对于没有具体返回值的情况,返回值用关键字void表示,那么该函数中的return如果在最后一行可以省略不写。
注意:1.函数中只能调用函数,不可以函数内部定义函数.
2.定义函数时,函数的结果应该返回给调用者,交由调用者处理。
3.写代码的规范:主类只负责调用,其他功能在其他类中完成!方便后来的复用。
数组
定义:具有相同数据类型的一组数据的集合。Java中数组是被看作一个对象,程序设计中引入数组可更有效地管理和处理数据。数组分为一维与多维数组。
初始化一维数组,初始化一维数组有两种方法:
1)静态初始化int arr [] = new int []{34,65,87,41};
2)动态初始化int arr [] = new int [4]; arr[0] = 34 ; arr[1] = 68 ; arr[2] =87 ; arr[3] = 41 ;
数组的长度:数组的长度可以通过数组名.length 获得。
数组的遍历:可以通过已知的数组长度来达到遍历数组的目的,也可以通过JDK1.5的新增功能来遍历数组。
数组的下标:数组的下标由0开始,所以数据的最大下标为 (数组名.length -1);
数组常见的异常:如果访问数组时索引越界(小于0或者大于length-1),会抛出异常:ArrayIndexOutOfBoundsExcepion
如果访问数组的引用为空(null),会抛出空指针异常:NullPointerException
public class TestWhile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = { 54, 41, 74, 96, 87, 45, 65, 41 };
System.out.println("数组的长度:" + arr.length);
System.out.println("数组中的元素有:");
//根据数组长度遍历数组
for (int i = 0; i < arr.length; i++) {
if (i != arr.length -1)
//根据数组下标输出数组成员
System.out.print(arr[i] + ",");
else
System.out.println(arr[i]);
}
}
}
输出:
数组的长度:8
数组中的元素有:
54,41,74,96,87,45,65,41
多维数组:所谓多维数组就是二维和大于二维的数组。多维数组的声明其实就是用一维数组的嵌套声明实现的。拿二维数组来举例,二维数组就是一个所有元素都是一维数组的一组数组。
二维数组也有两个方法初始化:
1) int [] [] a = new int [2][4];
2) int [] [] a = new int [2] []; a[0] = new int [4] ; a [1] = new int[4];(就是分别跟N个一维数组赋值)
上述代码创建的二维数组就是两个长度为4的一维数组组成。
论坛上看到的题目:求最值和素数
/**
1.输入10个数,求最值。
2.求输入的10个数是中素数之和。
要求:
1.使用多种方法来操作,比较方法的优缺点。
2.在每个方法的注释上写清楚编程思路。
3.一定要使程序清晰。
*/
import java.util.Arrays;
import java.util.Scanner;
public class Practice
{
public static void main(String[] args)
{
Practice pra = new Practice();
pra.manager();
System.out.println("Hello World!");
}
//代理类---其实可以写在main()中,不过想想还是分开吧!
public void manager(){
Scanner input = new Scanner(System.in);
System.out.println("请输入十个数:");
int count = 0 ;
int [] arr = new int[10];
//循环向数组输出数值
while (count < 10)
{
System.out.print("输入第" + (count + 1 ) + "个数:" );
arr[count++] = input.nextInt();
}
System.out.println("数组中的素数之和为:" + getPrime(arr));
//比较大小的有三种方法
//1.直接比大小,最简单的方法
System.out.println("输入数最大值为:" + getMax(arr));
//2.用数组的sort()方法排序:数组中的下标最大值为最大值
System.out.println("输入数最大值为:" + getMax2(arr));
//冒泡排序法
System.out.println("输入数最大值为:" + getMax3(arr));
//选择排序法
System.out.println("输入数最大值为:" + getMax4(arr));
}
//求最佳的方法1,直接遍历比较,返回最大值者
public int getMax(int [] arr){
//设第一个数为最值
int max = arr[0];
//循环比较
for ( int i = 1; i < arr.length ; i ++ )
{
//若大于max,则将其值赋予max
if (max < arr[i])
{
max = arr[i];
}
}
//返回max
return max;
}
//直接用Arrays中的方法实现排序
public int getMax2(int [] arr){
Arrays.sort(arr);
//返回数组的最后一位,也就是最大值了
return arr[arr.length -1];
}
/*
*冒泡排序法:一个一个比较大小,大的向极位移动
*优点就是实现思想比较简单,让人容易了解,比较稳定
*缺点就是要经常作变量交换,比较耗时
* */
public int getMax3(int [] arr){
//一个中间变量,用来作变量交换
int temp;
//遍历数组
for (int i = 1 ; i < arr.length ; i ++)
{
//比较相邻的幸免于难,较大者则往后
for ( int j = 0 ; j < arr.length - i ; j ++ )
{
//若前一位数比后一位数大,则交换位置
if (arr[j] > arr[j+1])
{
temp = arr[j];
arr[j ] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//返回最后一位数组,即是最大值
return arr[arr.length -1];
}
/*直接排序法,就是遍历数组将最大值放在最后位,次值放在后二位的做法
* 优点:算法交换的次数比冒泡排序要少,所以比较节省时间
* 缺点:比较不稳定
* */
public int getMax4(int [] arr){
//设中间值,作数据交换之用
int temp;
//遍历数组
for ( int i = 1 ; i < arr.length ; i ++)
{ //索引变量
int index = 0 ;
//比较各数,排序
for ( int j = 1 ; j <= arr.length - i ; j ++ )
{
//比较两者,大者下标为index
if (arr[j] > arr[index])
{
index = j;
}
}
temp = arr[arr.length - i];
//循环结束后再将其进入数据交换
arr[arr.length - i] = arr[index];
arr[index] = temp;
}
return arr[arr.length -1];
}
//求素数的方法
public int getPrime(int [] arr ){
//获取数组中的素数之和
int sum = 0;
System.out.print("数组中的素数为:");
//遍历数组
for ( int i = 0; i < arr.length ; i ++ )
{
/*
* 用一个布尔常量表示是否是素数
* 判断数组中的每一个数是否是素数,循环条件为该数的 1 / 2 ,因为除了2外偶数都不是素数,
* 而将该数除以 它一半和之前的数就可以判断它是否为素数
* */
boolean isPrime = true;
for ( int j = 2 ; j <= arr[i] / 2; j ++ )
{
//如果一个数能被它一半以下的数整除,那它就不是素数
if ( arr[i] % j == 0)
{
//此处的布尔值为不是素数
isPrime = false;
//一旦能整除退跳出循环,不用再判断
break;
}
}
if (isPrime)
{
//输出素数
System.out.print(arr[i] + "\t");
//将它们的和相加
sum += arr[i];
}
}
System.out.println("素数之和为:" + sum);
//返回素数结果
return sum;
}
}
3.编程练习
3.1按输入的数字输出相应长度的菱形
import java.util.Scanner;
public class Diamond {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入要输出的菱形的长度:");
int num = input.nextInt();
printDiamond(num);
}
public static void printDiamond(int num) {
// 计算菱形的大小,若输入为双数则加一
if (num % 2 == 0)
num++;
for (int i = 0; i < num / 2 + 1; i++) {
// 输出左上角的空白
for (int j = num / 2 + 1; j > i + 1; j--)
{
System.out.print(" ");
}
// 输出菱形上半部分实体
for (int j = 0; j < 2 * i + 1; j++)
{
System.out.print("*");
}
System.out.println();
}
for (int i = num / 2 + 1; i < num; i++) {
// 输出左下角的空白
for (int j = 0; j < i - num / 2; j++)
{
System.out.print(" ");
}
// 输出菱形下半部分实体
for (int j = 0; j < 2 * num - 2 * i - 1; j++)
{
System.out.print("*");
}
System.out.println();
}
}
}
输出:
请输入要输出的菱形的长度:12
*
***
*****
*******
*********
***********
*************
***********
*********
*******
*****
***
*
3.2计算1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! ;
public class Diamond {
public static void main(String[] args) {
manager();
}
private static void manager() {
// TODO Auto-generated method stub
//设总和为sum
double sum = 0;
//循环加1~1/20之间的和
for(int i = 1; i <= 20 ; i ++ ){
//每个阶乘的值
double partSum = 1 ;
for (int j = 1; j <= i; j++) {
//j的阶乘
partSum *= j;
}
sum += 1 / partSum;
}
//输出
System.out.println("1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! = " + sum);
}
}
输出:
1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! = 1.7182818284590455
3.3打印出10行的杨辉三角;
/**
* 思路:杨辉三角的定义,
* 一个数前提:端点的数为1.
* 1、每个数等于它上方两数之和。
* 2、每行数字左右对称,由1开始逐渐变大。
* 3、第n行的数字有n项。
* 由杨光三角的定义可知,此数列应用二维数组来做
* 且每一个一维数组的长度为其下标加一
* 由定义可知,除杨辉三角的边界为1外,其里面的元素triangle[i][j] = triangle[i-1][j] + triangle[i][j-1];
*
* */
public class YanghuiTriangle
{
public static void main(String[] args)
{
//调用输出杨辉三角的方法
triangle();
}
//输出杨辉三角的方法
public static void triangle(){
//新建一个长度为10的二维数组
int [] [] triangle = new int [10][] ;
//按二维数组的长度来循环
for ( int i = 0 ; i < triangle.length ; i ++ )
{
//输出左边的空格
for(int j = triangle.length -1 - i; j > 0 ; j --){
System.out.print(" ");
}
//每次循环都新建一个一维数组,长度为数组元素下标加一
triangle [i] = new int[i + 1];
for ( int j = 0 ; j <= i ; j ++)
{
//边界输出1
if(i == 0 || j == 0 || j == i )
triangle[i][j] = 1;
else
//里面的元素按上面的公式定来计算
triangle[i][j] = triangle[i - 1] [j] + triangle[i -1][j -1];
//输出每个值
System.out.print(triangle[i][j] + " ");
}
//第一循环换一行
System.out.println();
}
}
}
输出:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
-----------
android培训
、
java培训
、java学习型技术博客期待与您交流! ------------