Java语法

发表于 分类于

了解JAVA

JAVA的三种技术架构：

JAVA SE: 标准版java，可以开发一般的程序，java语言的标准。

JAVA EE：企业版java，针对web应用程序开发。

JAVA ME：主要用于开发移动程序，被Android取代。

java开发环境：

Jre：Java Runtime Environment Java运行环境

Jvm：Java Virtual Machine java虚拟机，和“核心类库” 组成了jre，jre只能运行java程序，开发java程序的话还需要JDK

JDK：Java Development Kit 开发工具包；Jdk=开发工具包+jre（jvm+核心类库）

HelloWorld

1
2
3
4
5
6
7
class Demo//用class关键字定义一个主类叫 Demo
{
    public static void main(String[] args)//定义一个主方法，格式固定
    {
        System.out.println("Hello World");//系统.输出.打印+换行（没有ln就少一个换行）
    }
}

编译过程：

java代码 ———> javac编译 ———> 机器语言，由jvm来执行生成的class文件

注释：

和c通用的，另加一个“文档注释”

1
2
3
4
5
/**
	@author 作者
	@version 版本 @符号也是可以被解析的
	注释的内容
*/

运算

数据类型:

变量的定义格式：

  • 整数默认int类型，定义long类型的数据时，要在数据后面加L。

  • 浮点数默认double类型，定义float类型的数据时，要在数据后面加F。

数据类型的转化：

1.占内存小的数据可以转化为占内存大的数据。

强制转化与C语言相同

1
2
3
4
5
double a = 3.14;
int b = (int)a;
//注意！！！
int c = (int)a+2.72；(报错)
int c = (int)(a+2.71);（成功）

算数运算：

运算符两侧的数据类型要保持一致

  1. +：可以连接两个字符串，可以算数，可以算数和连接
1
2
3
4
5
6
int a = 10;
int b = 20;
char c = 'c';
System.out.println(a+b+"hello"); //30hello
//注意区分
System.out.println("hello"+a+b); //hello1020
  1. 可以用自增自减运算符

关系运算符的结果是boolean类型；true 或者是 false（java的bool类型只有true和false）

&& \ \ ！

与C语言一样

三元运算符：

表达式1 ? 表达式2 ： 表达式3;

表达式1如果真，就执行表达式2，否则就执行3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Scanner;
public class compare {
    public static void main(String[] a)
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("input two num: ");
        int in1 = sc.nextInt();
        int in2 = sc.nextInt();
        int max = Cmp(in1,in2);
        System.out.println("较大的是："+max);
    }
    public static int Cmp(int a, int b)
    {
        return (a>b) ? a:b;					//这里直接返回二者中较大的值
    }
}

获得键盘输入：

过程：

导包———->创建对象————>接受数据

1
2
3
import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int input = sc.nextlnt();

运用实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Scanner;		//先导入需要的包，结尾需要分号
public class compare {
    public static void main(String[] a)
    {
        Scanner sc = new Scanner(System.in);		//new一个对象
        System.out.println("input two num: ");
        int in1 = sc.nextInt();						//这里进行输入
        int in2 = sc.nextInt();
        int max = Cmp(in1,in2);
        System.out.println("较大的是："+max);
    }
    public static int Cmp(int a, int b)
    {
        return (a>b) ? a:b;
    }
}

这里其实的输入形式有多种

1
2
3
4
5
6
nextInt();//这就是输入一个int类型的数
nextLine();//输入一个String类型
nextByte();//byte类型
next();//这个一般配合 next().charAt(0)来当作输入一个char类型使用
nextFloat();//输入一个浮点型
……

如何用IDEA

  • 点击文件
  • 新建项目（不能像dev一样单文件运行）
  • 选Groovy
  • 下一步
  • 下一步
  • 起项目的名字，选目录
  • 完成之后进入项目
  • 找到“src”文件，在里面新建java类，不要在外面那个.java文件里写，执行不了
  • 写好之后直接shift+f10，可以创建多个文件写，切换的时候要第一次用ctrl+shift+f10，不然会一直运行上一个文件

这里在src目录中可以建立多个文件，多个文件中可以包含多个main函数，但是class类的名字在众多文件中最好不要同名，会出bug

方法和函数

方法又称函数，可以独立运行，和main属于并列关系

定义一个函数

1
2
3
4
5
函数修饰符 函数返回值类型 函数名(参数类型 参数名，参数类型 参数名…… )
{
	……
	return 返回值（必须要符合先前的定义）
}

打印水仙花数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Scanner;
public class W_F
{
    public static void main(String[] arge)			//main函数的参数是规定要这么写，不写会报错
    {
        Scanner input = new Scanner(System.in);
        System.out.println("输入一个三位数，打印出里面的所有水仙花数：");
        int max = input.nextInt();
        find(max);

    }
    public static void find(int a)
    {
        int e,b,c,d;
        int p;
        for(;a>100;a--)
        {
            b = a%10;
            c = a%100 / 10;
            d = a / 100;
            p = (d==b)?a:0000;
            System.out.println(p);
        }
    }
}

重载：

同一个程序中，有多个同名函数，但是他们的参数列表不同，称为函数重载

参数引用：

正常传参的话是正常的

在传递数组的时候要注意，引用函数修改数组之后，数组在原函数中也会发生变化（相当于传递了一个指针进去）

运用switch case：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import javax.swing.plaf.synth.SynthEditorPaneUI;

public class Switch {
    public static void main(String[] arge)
    {
        int a[] = {2,4,1,5,6,3,6,8,9,56,11,4,10,12,7,22};
        for(int i=0;i<a.length;i++)
        {
            switch (a[i])
            {
                case 1:
                case 2:
                case 3:
                    System.out.println("春天");
                    break;
                case 4:
                case 5:
                case 6:
                    System.out.println("xia天");
                    break;
                case 7:
                case 8:
                case 9:
                case 10:
                    System.out.println("dong天");
                    break;
                case 11:
                case 12:
                    System.out.println("qiu天");
                    break;
                default:
                    System.out.println("fuck");
                    break;
            }
        }
    }
}

和c语言基本一样

数组的输入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.util.Scanner;
public class score
{
    public static void main(String[] arge)
    {
        System.out.println("输入成绩: ");
        float[] score = new float[5];
        edit(score);
        for (int i=0;i<score.length;i++)
        {
            System.out.println(i+" got "+score[i]);
        }
        Sum(score);
    }
    public static void edit(float[] a)
    {
        for(int i=0;i<5;i++)
        {
            Scanner input = new Scanner(System.in);
            System.out.print(i+": ");
            a[i] = input.nextFloat();
        }
    }
    public  static void Sum(float[] a)
    {
        float sum=0;
        int i=0;
        for (i=0;i<a.length;i++)
        {
            sum+=a[i];
        }
        System.out.println("总成绩: "+sum);
        System.out.println("平均成绩: "+sum/i);
    }
}

数组反转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.awt.print.Printable;
public class arryre
{
    public static void main(String[] are)
    {
        int[] a = new int[10];//这里注意区分 一些数组的定义形式
        int i=0;
        for (i=0;i<10;i++)
        {
            a[i] = i;
        }
        Print(a);
        int temp;
        for (i=0;i<5;i++)
        {
            temp = a[i];
            a[i] = a[a.length-1-i];
            a[a.length-1-i] = temp;
        }
        Print(a);
    }
    public static void Print(int[] a)
    {
        int i=0;
        for(i=0;i<a.length;i++)
        {
            System.out.print(a[i]);
        }
        System.out.println();
    }
}

java里面没有像python的index函数一样的数组元素定位的方法，要自己实现一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Scanner;
public class Index
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        int num;
        int[] a={1,2,3,4,5,6,7,8,9,11,22,33,44,55,66,77,88,99};
        System.out.println("请输入你要查找的数: ");
        num = input.nextInt();
        int addr = getIndex(a , num);
        System.out.println(addr);
    }

    public static int getIndex(int[] a, int num)
    {
        int i;
        for (i=0;i<a.length;i++)
        {
            if (a[i] == num)
            {
                return i;
            }
        }
        return 0;
    }
}

面向对象思想

同时存在 面向对象和 面向过程两种思维方式，面向：关注的意思

  • 面向过程：自己为了解决需求自己所构建的函数。
  • 面向对象：为了解决需要寻找具备某些功能的对象，来构建程序。

A:面向过程：强调的是过程，所有事情都需要自己完成

B:面向对象: 面向对象更加符合我们的思考习惯，自己不要那么辛苦，而我们仅仅只需要指挥或者找具备相应功能的对象帮助我们做事即可。

类：

类：代码都必须有指定的存放位置，这个位置成为“类”（class）。

用Java中的类描述当前分析的这个事物：事物的名称，就是Java中的类名。

当描述完一个事物之后，要在Java程序中使用这个事物，首先需要使用new 关键字创建出这个事物在Java中的对象，然后通过这个对象就可以调用其中的所有特征。（类似于结构体）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Person//定义了一个person类
{
    String name;
    int age;
    String sex;
    String job;

    void sleep()
    {
        System.out.println("sleep");
    }

    void eating()
    {
        System.out.println("have food");
    }
}

class Tperson//定义一个主类，如果不运行的话可以没有main函数
{
    public static void main(String[] arg)
    {

        Person per1 = new Person();//new一个新的对象
//像C语言的结构体一样进行赋值
        per1.age = 18;
        per1.name = "小王";
        per1.job = "后勤管理";
        per1.sex = "女";
        //这样就会调用类中的方法（函数）
        per1.sleep();
        per1.eating();
    }
}

变量：

局部变量：

定义在函数中的变量。

成员变量：

定义在类的成员位置上的变量，在整个类中都有效的变量(全局变量也是一种成员变量)

成员变量又分为 实例(对象)变量 和 类变量(static静态变量)。

函数总是优先使用局部变量，从内往外找

封装：

通过private关键字限制变量的访问权限：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class Private
{
        String name;
        String job;
        private int age;//这里用private给他限制住

        public void editage(int num)
        {
            if (num>0 && num <200)
            {
                age = num;
            }else
            {
                System.out.println("fuck you");
            }
        }//这里就可以对输入进行检查，从而保证age一定是正的

        public void Printage()
        {
            System.out.println(age);
        }//因为被限制了，所以打印也要在这个类里面打印
}
class Teperson
{
    public static void main(String[] arge)
        {
            Private per = new Private();
            per.name = "FUCK";
            per.job = "Mother";
            per.editage(19);//间接调用
            System.out.println(per.job);
            System.out.println(per.name);
            per.Printage();
        }
}

开发中的书写习惯：

一个类中成员变量全部私有，对外提供getXxxx函数或者setXxxx函数 ， Xxxx表示的成员变量的名字，而成员变量的名字中的第一个字母要大写。

\1) 在开发中如果在外界想给类中的私有成员变量赋值，那么通过类中的setXxxx函数进行对该成员变量赋值。

\2) 在开发中如果在外界想使用类中的私有成员变量，那么通过类中的getXxxx函数获得该成员变量。

编程习惯是要通过间接的方式对类的内容进行访问

this关键字：

方法被哪个对象调用，在方法中就会有一个隐式的变量this记录着调用对象的地址。

当局部变量和成员变量重名时。使用this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import java.util.Scanner;

public class This//定义一个public类
{
    private String name;
    private int score;
    //都是私有变量
    void editName(String name)
    {
        this.name = name;
    }
    //在类中定义的函数，函数的参数和类的成员变量是重名的，这里使用this关键字来区分成员变量
    void editscore(int score)
    {
        if (score>0 && score<200)
        {
            this.score = score;
        }
    }
}

class Testthis // 定义一个新的测试类
{
    public static void main(String[] arges)
    {
        Scanner input = new Scanner(System.in);
        This per = new This();
        //这里的输入和自定义类其实是一样的，类名 变量 = 在类中new一个
        String name;
        int num;
        System.out.print("姓名:");
        name = input.nextLine();
        System.out.print("成绩:");
        num = input.nextInt();
        per.editName(name);
        per.editscore(num);
    }
}

其他关键字：

public：公开的类或者是变量，所有的类都可以进行使用或者引入（都可以用）

protected：受保护的类，只有子孙类和本类可以引入使用（同包或者同类）。这也是默认的类，如果class前面什么也不加就默认是protected。

private：只有在本类中才可以使用（同类）

public void 修饰是非静态方法，该类方法属于对象，在对象初始化（new Object()）后才能被调用；

public static void 修饰是静态方法，属于类，使用类名.方法名直接调用。

构造函数：

是什么：在创建对象时会自动调用的函数

使用new关键字创建对象，创建完之后，就会调用当前这个类的构造函数

1
new Class()//就是说以无参数构造方法实例化对象。

与一般函数的区别：

一般函数的定义格式：

修饰符 返回值类型 函数名（参数列表）

{

}

构造函数（方法）格式：没有返回值类型，他也不需要

修饰符 构造函数名（ 参数列表 ）

{

}

构造函数的名字要求必须和当前的类名一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.util.Scanner;

class Stu
{
    private String name;
    private int age;

    void EditAge()
    {
        System.out.println(age);
    }

    void EditName()
    {
        System.out.println(name);
    }

    Stu (String name, int age)//构造函数
    {
        this.name = name;
        this.age = age;
    }
}

public class build_func
{
    public static void main(String[] agre)
    {
        Scanner input = new Scanner(System.in);
        String name = input.nextLine();
        int num = input.nextInt();
        Stu stu1 = new Stu(name , num);//在new对象的时候直接就进行初始化
        System.out.println("测试构造函数");
        stu1.EditAge();
        stu1.EditName();
    }
}

这是自己写出来构造函数，如果没有的话就是默认构造函数，java经过javac编译之后会自动添加一个没有参数的构造函数。

根据不同的需要可以在类中同时写有参数的和没有参数的构造函数，他们以 重载的形式存在于类中。在new的时候根据参数的不同选择构造函数。

构造函数和一般函数对比

  • 构造函数当对象创建完成了，函数也执行完成了。

  • 构造函数只有在new对象的时候，会被调用，一旦对象创建完成，我们不能手动的人为去调用构造函数。

  • 构造函数可以调用一般函数，反之不行

构造函数的相互调用：

用this关键字，不能通过函数名调用构造函数

  1. 构造函数不能相互嵌套调用，不然会导致程序选入死循环

  2. this调用构造函数，必须放在构造函数的第一句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class student
{
    String name;
    int score;

    student()
    {
        System.out.println("这是无参构造函数");
    }

    student(String name)
    {
        this.name = name;
        System.out.println("这是1参构造函数");
    }

    student(String name , int num)
    {
        this("lala");        //这里通过this用了一参数的构造函数
        this.name = name;
        score = num;
        System.out.println("这是2参构造函数");
    }

    void showinfo()
    {
        System.out.println(name+" 考了: "+score);
    }
}
public class buildFunc2
{
    public static void main(String[] arge)
    {
        student stu = new student("陈润基",100);
        stu.showinfo();
    }
}

如果这里不把this的调用放在第一行，那么这里就会报错说

对this的调用必须是构造器中的第一个语句

常用API

API：application programming interface。应用程序接口。

Scanner类 与 String类：

scanner：

相当于时scanf函数用来接受外部输入

1
2
3
4
5
6
7
8
9
import java.util.Scanner;
public class Input
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        String name = input.nextLine();
    }
}

string类：

Java中的所有常量：整数、小数、字符、字符串、null、真假值true false

由此可知，String类型不是java的基本数据类型，属于是引用类型，也成为 类类型

它不是存储在堆空间中，而是存储在方法区中的字符串常量池中。字符串常量池中保存的就是所有的字符串数据。只要我们书写了双引号，不管双引号中间是什么数据，这些数据都会立刻在字符串常量池中保存。

1
2
3
4
5
6
7
8
9
public class StringDemo
{
    public static void main(String[] args)
    {
        String a = "abcd";
        String b = "abcd";
        System.out.println(a == b); //true
    }
}

使用String类的构造函数创建的对象，那么这个对象就会在堆中出现。而在创建出的字符串对象中的字符数据保存在常量池中。

使用String类的默认构造函数:

byte类型：

1
2
3
4
5
6
7
8
9
10
11
public class byte2string
{
    public static void main(String[] args)
    {
        byte[] b = {65,66,67,68,97,99,121};
        String s = new String(b);
        String s1 = new String(b,0,3);//数组，从0开始，往后数3个
        System.out.println(s);//ABCDacy
        System.out.println(s1);//ABC
    }
}

字符数组类型：

将数组转换成string类型的话

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Char2string
{
    public static void main(String[] args)
    {
        char[]  c = {'H','e','l','l'};
        int[] i = {1,2,3,4,5,6,7,8};
        
        String s = new String(c);
        String s1 = new String(i,0,3);
        
        System.out.println(s);
        System.out.println(s1);//这里还是进行一个ascii的转化
    }
}

String类的运算操作：

比较：

1
2
3
4
boolean equalsIgnoreCase(String str)//比较字符串的内容是否相同,忽略大小写
boolean startsWith(String str)		//判断字符串对象是否以指定的str开头
boolean endsWith(String str)		//判断字符串对象是否以指定的str结尾

这里不能用==来进行String类型的判断

1
2
3
4
5
int length()					//获取字符串的长度，其实也就是字符个数
 char charAt(int index)		//获取指定索引处的字符
 int indexOf(String str)		//获取str在字符串对象中第一次出现的索引
 String substring(int start)	//从start索引开始截取字符串，截取到字符串最后
 String substring(int start,int end)//从start开始，到end结束截取字符串。包括start，不

类型转换：

1
2
3
char[] toCharArray()//把字符串转换为字符数组，相当于list了
String toLowerCase()//把字符串中的所有大写字母转换为小写字母
String toUpperCase()//把字符串中的小写字母转换为大写字母

切割方法：

1
2
String trim()//去除字符串两头的空格
String[] split(String str)//按照给定字符串进行分割

字符串缓冲区：

Java中提供2个字符串缓冲区StringBuffer和StringBuilder。

集合的概念

引出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Stud
{
    String name;
    int score;
    int age;

    public Stud(String name, int score, int age)//构造函数必须和类同名
    {
        this.age = age;
        this.name = name;
        this.score = score;
    }
}
public class DemoArry
{
    public static void main(String[] args)
    {
        Stud[] arr = new Stud[3];
        Stud stu1 = new Stud("小明", 18 , 66);
        Stud stu2 = new Stud("小张", 19 , 88);
        Stud stu3 = new Stud("小王", 21 , 99);
        arr[0] = stu1;
        arr[1] = stu2;
        arr[2] = stu3;
        for(int i=0; i<3; i++)
        {
            System.out.println(arr[i].name+' '+arr[i].age+' '+arr[i].score);
        }
    }
}

注意，因为我在同一个src目录下创建的，然后后来应该是定义类的时候和前面的哪一个重名了，一直报错，把类名改一下就可以了

这里定义一个数组的方法

如果使用数组存储int类型的数据：int[] arr=new int[3];

如果使用数组存储String类型的数据：String[] arr=new String[3];

如果使用数组存储Student类型的数据：Student[] arr=new Student[3];

和结构体里面定义数组差不多

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import java.util.Scanner;
class Stud
{
    String name;
    int score;
    int age;

    public Stud(String name, int score, int age)//构造函数必须和类同名
    {
        this.age = age;
        this.name = name;
        this.score = score;
    }
}
public class DemoArry
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        int len = input.nextInt();
        String name;
        String bin;
        int score;
        int age;
        String[] nm = {"a","b","c","d","e","f"};
        Stud[] arr = new Stud[len];
        for(int i=0;i<len;i++)
        {

            System.out.println("score: ");
            score = input.nextInt();
            System.out.println("name: ");
            bin = input.nextLine();//这里先把回车过滤过去，不然name就成回车了
            name = input.nextLine();
            System.out.println("age: ");
            age = input.nextInt();
            arr[i] = new Stud(name, score , age);
        }
        for(int i=0; i<len; i++)
        {
            System.out.println(arr[i].name+' '+arr[i].age+' '+arr[i].score);
        }
    }
}

这个程序要注意的就是那个字符串name的输入函数，先用一个输入过滤掉回车

集合：一种存放对象的容器

集合的概念：一种存放对象的容器，需要使用对象的事后，把对象取出来，再去使用，方便快捷

集合和数组的区别：

  • 数组是固定长度，集合长度可变

  • 数组可以存储基本类型数据和引用类型数据（String类型和上面定义的Stud类型），集合只能存储引用类型的数据

  • 数组的数据都是类型相同的，集合允许元素的类型不同

ArrayList集合：

她的底层就是大小可变的数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.ArrayList;
//引入ArratList包
public class ArrayListDemo
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();//创建一个集合对象

        list.add("hello");
        list.add(" world");
        list.add("test end");
        list.add(2, "android");//如果不指定位置就从头往后插入
        
        System.out.println(list);   //[hello,  world, android, test end]
    }
}

增添删改：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.ArrayList;
import java.util.Scanner;
public class ArrayListDemo
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        ArrayList<String> list = new ArrayList<String>();
        System.out.println("输入集合的元素个数");
        int len = input.nextInt();
        int i=0;
        String str;
        String bin;
        bin = input.nextLine();
        for(;i<len;i++)
        {
            str = input.nextLine();
//            str = (String)(char)i;
            list.add(str);
        }
        System.out.println("刚刚输入的是");
        System.out.println(list.get(2));//可以通过get的形式类遍历整个集合
        System.out.println(list.get(3));
        list.remove(2);//删除第二位之后，后面的会向前进一位
        list.set(2, "99");//注意这里修改的事后要类型合适
        System.out.println(list.get(2));
        System.out.println(list.get(3));
        System.out.println(list.size());//size返回集合元素个数
    }
}

增强for循环：

这是看idea下面的提示才知道还有这么一回事

1
2
3
4
for(Object obj : list) //使用增强for循环遍历集合
{
	System.out.println(obj);//取出并打印集合中的元素
}

这个东西就像是python里的

1
2
for i in list:
    print i

一样，不用再用get方法在集合里取值了，但是这里只能访问，不能修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import java.util.Scanner;
import java.util.ArrayList;

class Book
{
    String title;
    int price;
    String author;

    public Book(String title, String author, int price)
    {
        this.title = title;
        this.author = author;
        this.price = price;
    }
}

public class SelfClassArray
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        ArrayList<Book> book = new ArrayList<>();
        char op;

        while (true)//不能直接while 1，因为她的bool类型只有true和false
        {
            System.out.print("输入 '#' 退出: ");
            op = input.next().charAt(0);
            if (op == '#')
            {
                PrintBook(book);
                break;
            }
            else
            {
                addBook(book);
            }
        }
    }

    public static void PrintBook(ArrayList<Book> list)
    {
        System.out.println("下面是您输入保存的书目录：");
        System.out.println("作者  书名  价格");
        for (Book elm :list)
        {
            System.out.println(elm.author+": "+elm.title+" --> "+elm.price+"$");
        }           //这里使用了加强版for循环
    }//这里打印不能只println(elm)，每一个元素都相当于一个对象，这里的要打印出对象中的数据，否则会报错

    public static void addBook(ArrayList<Book> list)
    {
        Scanner input = new Scanner(System.in);

        System.out.print("书名：");
        String name = input.nextLine();

        System.out.print("作者：");
        String author = input.nextLine();

        System.out.print("价格：");
        int price = input.nextInt();

        Book temp = new Book(name, author, price);
        list.add(temp);//这list里面都是一个个的对象
        //每个对象对应这自己的数据
    }
}

如上程序用了ArrayList将自定义的对象进行复制并且在退出之前进行遍历

学生管理系统-java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
/*查看所有的学生信息，可以增加，修改，删除学生信息，学生信息包括学号，姓名，年龄，籍贯*/
import java.util.Scanner;
import java.util.ArrayList;

class allstu
{
    private String name;
    private String addr;
    private int age;
    private String stuid;

    public allstu(String name, String addr, String stuid, int age)
    {
        this.addr = addr;
        this.name = name;
        this.stuid = stuid;
        this.age = age;
    }

    void showname()
    {
        System.out.print(name+": ");
    }
    void showaddr()
    {
        System.out.print(addr+" ");
    }
    void showid()
    {
        System.out.print(stuid+" ");
    }
    void showage()
    {
        System.out.print(age+"  。");
    }
}

public class studentManager
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        ArrayList<allstu> stu_list = new ArrayList<>();
        while (true)
        {
            Printalbe();
            int op = input.nextInt();
            switch (op)
            {
                case 1:
                    showInfo(stu_list);
                    break;
                case 2:
                    System.out.print("要删除哪一个: ");
                    int index = input.nextInt();
                    rmInfo(stu_list, index-1);
                    break;
                case 3:
                    addInfo(stu_list);
                    break;
                case 4:
                    System.out.print("要修改哪一个: ");
                    int index1 = input.nextInt();
                    setInfo(stu_list, index1-1);
                    break;
                case 5:
                    System.out.println("感谢使用");
                    System.exit(0);
            }
        }
    }

    public static void Printalbe()
    {
        System.out.println("--------欢迎来到学生管理系统--------");
        System.out.println("1. 查看所有");
        System.out.println("2. 删除");
        System.out.println("3. 增加");
        System.out.println("4. 修改");
        System.out.println("5. 退出");
        System.out.print("选择: ");
    }
    public static void addInfo(ArrayList<allstu> stu)
    {
        Scanner input = new Scanner(System.in);

        System.out.print("姓名: ");
        String name = input.nextLine();

        System.out.print("地址: ");
        String addr = input.nextLine();

        System.out.print("学号: ");
        String id = input.nextLine();

        System.out.print("年龄: ");
        int age = input.nextInt();

        allstu temp = new allstu(name ,addr, id, age);
        stu.add(temp);

        System.out.println("添加成功");
    }

    public static void setInfo(ArrayList<allstu> stu , int index)
    {
        allstu temp = stu.get(index);

        temp.showname();
        temp.showid();
        temp.showaddr();
        temp.showage();

        Scanner input = new Scanner(System.in);

        System.out.print("姓名: ");
        String name = input.nextLine();

        System.out.print("地址: ");
        String addr = input.nextLine();

        System.out.print("学号: ");
        String id = input.nextLine();

        System.out.print("年龄: ");
        int age = input.nextInt();

        allstu new_stu = new allstu(name ,addr, id, age);

        stu.set(index , new_stu);					//这里直接就在原来的位置修改了，没有新增

    }

    public static void rmInfo(ArrayList<allstu> stu, int index)
    {
        stu.remove(index);
        System.out.println("删除完成");
    }

    public static void showInfo(ArrayList<allstu> stu)
    {
        if (stu.size() == 0)
        {
            System.out.println("没有信息");
        }
        else
        {
            for(allstu pre : stu)
            {
                pre.showname();
                pre.showid();
                pre.showage();
                pre.showaddr();
                System.out.println();
            }
        }
    }
}