首页 > 编程语言> > java初学笔记

java初学笔记

2022-03-25 13:34:03 作者：互联网

1

jre是java程序的运行环境，包含jvm和运行所需要的核心类库

想要运行已有的java程序，只需要运行jre就行了

jdk是java程序开发工具包，包含jre和开发人员使用的工具

包含编译工具(javac.exe)和运行工具(java.exe)

开发一个全新的java程序，必须安装jdk

2

开发java程序、需要三个步骤

编写程序、编译程序、运行程序

依旧是先编译然后执行

javac  helloworld.java
java   helloworld(其实是helloworld.class)

常见问题

中英文的符号进行

注意System.out.println

注释

单行注释

3

关键字就是被java语言赋予了特定含义的单词

全部小写
常用的代码编译器，对关键字有特殊的颜色标记

常量：

常量指的是在程序运行中，其值不可以发生改变的量

常量类型	说明	例子
字符串常量	用双括号括起来的	"hhh"
整数常量	不带小数的常量	666
小数常量	带小数的数字	13.124
字符常量	用单括号括起来的	'A','0'
布尔类型	布尔值、表示真假	只有两个
空常量	一个特殊的值	null

null空常量不能直接输出

数据类型

java数据类型有基本数据类型、引用数据类型

基本数据类型有数值型、非数值型

整数默认int

浮点数默认double

变量

在程序运行中，其值可以发生改变的量

从本质上讲，变量是内存中的一小块区域

格式：

数据类型变量名 = 变量值；

变量的注意事项

变量名不能重复

变量给值，不给值不能使用

对于

long i = 100000000;
会报错
需要进行
long i = 100000000L;
因为后面的数字默认是int的，需要加来进行确定是long类型

同理对于不兼容的类型，需要加F后缀

float a = 1000154543F;

标识符

由数字、字母、下划线和美元符组成

不能数字开头

不能关键字开头

区分大小写

常见命名约定

小驼峰命名方法、变量

标识符是一个单词的时候，首字母小写
标识符是一个多单词组成的，采用首字母小写，其他字母大写

大驼峰命名类

标识符是一个单词的时候，首字母大写
标识符是一个多单词组成的，每个字母都大写

自动转换

范围很小的数值或变量赋值给另一个表示数据范围很大的变量

byte不能到char

强制类型转换

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围很小的变量

强制类型转换不建议，因为会有数据的丢失

整数相除只能得到整数，要想得到小数，除数需要加浮点数参与才行

在一个算术表达式中，如果包含多个基本数据类型的值时，整个算术表达式的类型会自动提升

byte、short、char会自动提升到int

整个算数表达式中自动提升到最高操作数同样的类型

byte、short、char-->int---->long---->float----double

加操作

"it"+666
"it"+"mm"
666+"it"
还可以接着进行加
99+1+'a'
100a

在+操作，如果出现了字符串，就是连接运算符，不然就算术运算符，当连续进行+操作时，从左到右逐个进行

赋值运算符

扩展的赋值运算符隐含了强制类型转换

单独使用i++，++i都一样

参与操作有截然不同的区别的

关系型

=是赋值运算

==是关系判断

关系型运算符的结果都是boolean

要么true，要么false

逻辑运算

连接关系表达式的运算符

注意亦或的^

相同为false。不同为true

短路逻辑运算符

短路与和或与基本的逻辑运算符差不多

但短路与的&&只执行前面的

同理如果||左面为true，他也不执行了

三元运算符

格式：

关系表达式?表达式1:表达式2;

a>b?a:b;

导入数据

import java.util.Scanner;
public class hello{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int x=sc.nextInt();
        System.out.println("x: "+x);
    }
}

31

流程控制语句

分类：

顺序结构
按照代码的先后顺序来进行执行
分支结构
循环结构

if语句1

if语句2

奇数偶数

import java.util.Scanner;
public class hello{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int x =sc.nextInt();
        if (x%2==0){
            System.out.println(x+"偶数");
        }else{
            System.out.println(x+"奇数");
        }
    }
}

第三种情况

switch语句

对于一个训练关于case

最原始的是2

     case 1:
     dddddd
     case 2:
     ddddd
     可以对case1，case2进行合并，
     就像
     case1:
     case2:

for循环语句

for(初始化语句;条件判断语句;条件控制语句)
{
循环语句;
}

求和

public class hello {
    public static void main(String[] args) {
        int sum=0;
        for (int i=0;i<=5;i++){
            sum+=i;
        }
        System.out.println(sum);
    }
}

求1-100的偶数和

public class hello{
    public static void main(String[] args) {
        int sum=0;
        for(int i=1;i<=100;i++){
            if (i%2==0){
                sum+=i;
            }
        }
        System.out.println(sum);
    }
}

水仙花

public class hello{
    public static void main(String[] args) {
        for (int i=100;i<=999;i++){
            int ge=i%10;
            int shi=(i/10)%10;
            int bai=i/100;
            if (ge*ge*ge+shi*shi*shi+bai*bai*bai==i)
                System.out.println(i);
        }
    }
}

100-999的水仙花个数

public class hello{
    public static void main(String[] args) {
        int count = 0;
        for (int i=100;i<=999;i++){
            int ge=i%10;
            int shi=(i/10)%10;
            int bai=i/100;
            if (ge*ge*ge+shi*shi*shi+bai*bai*bai==i)
                count+=1;
        }
        System.out.println(count);
    }
}

while循环语句

折叠0.1的对珠穆朗玛峰

public class hello {
    public static void main(String[] args) {
        int count = 0;
        int zf=8844430;
        double paper=0.1;
        while(paper <=zf){
            paper*=2;
            count++;
        }
        System.out.println("max floder is "+count);

    }
}

do...while

死循环

for(;;)
while(true)

random函数

import java.util.Random;
public class hello {
    public static void main(String[] args) {
        Random r =new Random();
        int number=r.nextInt(10);
        System.out.println(number);
    }
}

idea快捷键

单行注释的取消与开始

ctrl+/

多行

ctrl+shift+/

格式化好看点

alt+ctrl+l

模块的

新建

删除

导入

数组

数组是一种用于存储多个相同类型的存储类型

定义格式有两种

数据类型[] 变量名
int[] arr
定义了一个int的数组类型，数组名为arr
数据类型 变量名[]
int arr[]
定义了一个int的变量，变量名是arr数组

java的数组必须先初始化才能使用

初始化：为数组中的数组元素分配内存空间，并为每个数组元素赋值

java数组的初始化方式

动态初始化

只指定数组长度，由系统为数组分配初始值
格式
数据类型[]变量名=new 数据类型
int[] arr=new int[3];

静态初始化

数组元素访问

java内存分配

int [] arr=new int [3];
System.out.println(arr);
System.out.println(arr[0]);
等

数组在默认初始化时，会为存储空间添加默认值

静态初始化:

指定每个数组元素的初始值，，由系统决定数组长度
数据类型[] 变量名 =new 数据类型[]{数据1、数据2等};
简化格式：
数据类型[] 变量名={数据1、数据2等};

常见数组问题

索引越界 
int[] arr=new int[3];
System.out.println(arr[3]);
索引越界
空指针异常
同上，但arr=null;
再访问就报错

数组遍历

for(int x=0;x<5;x++){
	System.out.println(arr[x]);
}

假如数组的里面的个数太多，就需要获取数组中元素的个数

arr.length
获取元素的个数

最大值

public class hello {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,66,55,88,9};
        int max=arr[0];
        for (int i=0;i<arr.length;i++){
            if (max<arr[i]){
                max = arr[i];
            }
        }
        System.out.println("max id "+max);

    }
}

九九乘法

public class hello {
    public static void main(String[] args) {
        for(int j=1;j<10;j++){
            for(int i=1;i<=j;i++){
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();
        }
    }
}

方法

方法就是将具有独立功能的代码块组织成一个整体，使其具有特殊功能的代码集

方法必须创建才可以使用，该过程称为方法的定义

方法创建后不是直接运行，需要手动使用后才执行，该过程称为方法调用

方法的定义

public static  void 方法名(){
//方法体
}

然后进行调用就是

方法名();

调用

public class hello {
    public static void main(String[] args) {
        isnum();
    }

    public static void isnum() {
        int number = 10;
        if (number % 2 == 0) {
            System.out.println("ggg");
        } else {
            System.out.println("assss");
        }
    }
}

方法必须先定义后调用

带参数方法的定义

格式：

public static void 方法名(参数){

}

参数的方法调用

public class hello {
    public static void main(String[] args) {
        oushu(6);
    }
    public static void oushu(int num){
        if (num%2==0){
            System.out.println("aaaa");
        }

    }
}

形参：方法中定义的参数

等同于变量定义格式，exp:int number

实参：方法调用的参数

等同于使用变量或常量

带返回值方法的定义和调用

public class hello {
    public static void main(String[] args) {
        boolean flag = isnum(10);
        System.out.println(flag);
        //还可以进行只isnum(109);但是没有值
    }
    public static boolean isnum(int a){
        if(a%2==0){
            return true;
        }else{
            return false;
        }
    }
}

调用方法的快速

System.out.println(isnum(6));
还可以进行
先
int number=isnum(a,b);
System.out.println(number);

方法的注意事项

不能嵌套

void表示无返回值，可以省略return，也可以单独写return，但不能加数据在后面

方法的通用格式

方法重载

方法重载是指在同一类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

public class hello {
    public static void main(String[] args) {
        int a=sum(1,2);
        System.out.println(a);
        double b=sum(1.0,2.0);
        System.out.println(b);
    }
    public static int sum(int a,int b){
        return a+b;
    }
    public static double sum(double a,double b){
        return a+b;
    }
}

对于基本数据类型的参数，形式参数的改变，不影响实际的参数的值

方法参数传递

对于引用类型的参数，形式参数的改变，影响实际参数的值

数组遍历

[1,2,22,33]

对于不返回return的需要void，返回return的才用类型参数

部分数组遍历

public class hello {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44};
        shuzu(arr);
    }

    public static void shuzu(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ",");
            }
        }
        System.out.print("]");
    }
}

数组最大值

public class hello {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44};
        System.out.println(shuzu(arr));
    }

    public static int shuzu(int[] arr) {
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if (max<arr[i]){
                max=arr[i];
            }
        }
        return max;
    }
}

debug

可以用于查看程序的执行流程，也可以用来追踪程序执行过程调试程序

调试结果看控制台

删除断点批量

练习

第一个
就是对输入的数字进行判断
先导入包
创建对象
接收数据
if太简单
使用switch进行
类似
import java.util.Scanner;

public class hello{
    public static void main(String[]args){
        Scanner sc=new Scanner(System.in);
        System.out.println("?");
        int week=sc.nextInt();
        switch(week){
            case 1:
                System.out.println("aaa");
                break;
            case 2:
                System.out.println("bbb");
                break;
        }
    }
        }

逢7必过

public class hello{
    public static void main(String[]args){
        for(int i=1;i<=100;i++){
            if (i%7==0 || i/10%10==7 || i%10==7)
                System.out.println(i);
        }
    }
        }

public class hello {
    public static void main(String[] args) {
        int[] arr = new int[20];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < arr.length; i++) {
            arr[i]=arr[i-1]+arr[i-2];
        }
        System.out.println("最后一个月的兔子的个数是"+arr[19]);
    }
}

三种动物的问题

public class hello {
    public static void main(String[] args) {
        for (int i=0;i<=20;i++){
            for(int j=0;j<=33;j++){
                int z=100-i-j;
                if (z%3==0&&5*i+3*j+z/3==100){
                    System.out.println(i+","+j+","+z);
                }
            }
        }
    }
}

比较数组是否相同

}

return true;

}

查找索引

基本的

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55};
        Scanner sc = new Scanner(System.in);
        System.out.println("?");
        int num = sc.nextInt();
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                index = i;
                break;
            }
        }
        System.out.println("suoyin is " + index);
    }
}

定义一个方法

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        int a=getindex(arr,2);
        System.out.println("max is "+a);
    }
    public static int getindex(int[] arr,int num){
        int index=-1;
        for(int i=0;i<arr.length;i++){
            if (arr[i]==num){
                index=i;
                break;
            }
        }
        return index;
    }
}

反转交换

public class hello {
    public static void main(String[] args) {
        int [] arr={1,23,44,55,66};
        reverse(arr);
        printa(arr);
    }
    public static void reverse(int[] arr){
        for (int start=0,end=arr.length-1;start<=end;start++,end--){
            int temp=arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
        }
    }
    public static void printa(int[] arr){
        System.out.print("[");
        for(int x=0;x< arr.length;x++){
            if(x==arr.length-1){
                System.out.print(arr[x]);
            }else{
                System.out.print(arr[x]+",");
            }
        }
        System.out.println("]");
    }
}

6个数，最高分最低分去掉，然后平均

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        int[] arr = new int[6];
        Scanner sc=new Scanner(System.in);
        for (int i=0;i<arr.length;i++){
            System.out.println("第"+(i+1)+"个成绩");
            arr[i]=sc.nextInt();
        }
        int max=getmax(arr);
        int min=getmin(arr);
        int sum1=sum(arr);
        int avg=(sum1-max-min)/ (arr.length-2);
        System.out.println("avg "+ avg);
        System.out.println("max "+ max);
        System.out.println("min "+ min);
        System.out.println("sum "+ sum1);

    }
    public static int getmax(int[] arr){
        int max = arr[0];
        for (int x=1;x<arr.length;x++){
            if (max<arr[x]){
                max=arr[x];
            }
        }
        return max;
    }
    public static int getmin(int[] arr){
        int min =arr[0];
        for (int x=1;x<arr.length;x++){
            if(min>arr[x]){
                min=arr[x];
            }

        }
        return min;
    }
    public static  int sum(int[] arr){
        int sum=0;
        for(int x=0;x<arr.length;x++){
            sum+=arr[x];
        }
        return sum;
    }
}

导包

第一种是输入import java.util.Scanner;

第二种是对输入过的Scnner进行点击按alt+enter（快捷键导

还有自动导包，就是Scanner输入然后会有java.util的自动导包

面向对象

什么是类？

类就是对现实生活中的一类具有共同属性和行为的事物的抽象

类的特点：

类是对象的数据类型
类是具有相同属性和行为的一组对象的集合

什么是对象的属性

属性：对象具有的各个特征，每个对象的每个属性都拥有特定的值

行为：对象能够执行的操作

对象：

是能够看的到摸得着的真实存在的实体

类是对象的抽象
对象是类的实体

类的定义

类：

是java程序的基本组成单位

类就是对现实生活中的一类具有共同属性和行为的事物的抽象

类的组成：属性和行为

属性：在类中通过成员变量来体现（类中方法外的变量

行为：在类中通过成员方法来体现（和前面的方法比去掉ststic关键字即可

类就是刚开始的

public class Phone

简单的类和定义

public class hello {
    String brand;
    int price;
    public void call(){
        System.out.println("打电话");
    }
    public void sendmessage(){
        System.out.println("打电话");
    }
}

对象的使用

先创建

类名 对象名=new 类名();
Phone p=new Phone();

使用对象

使用成员变量

格式：对象名.变量

范例：p.brand

使用成员方法

格式：对象名.方法名()

范例:p.call()

然后调用

两个地方
第一个地方
Phone类
public class Phone {
    String brand;
    int price;
    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("打电话");
    }
}
第二个地方
来调用这个类
public class hello {
    public static void main(String[] args) {
        Phone phone = new Phone();
        System.out.println(phone.brand);
        System.out.println(phone.price);
    }
}
赋值的话就是phone.brand
还有就是
phone.price
成员方法的使用
phone.call();

string默认值为null，int默认为0（在不赋值的情况下

成员变量和局部变量

成员变量：类中方法外的变量

局部变量：方法中的变量

private关键字

是一个权限修饰符
可修饰成员
作用是保护成员不被别的类使用，被private修饰的成员只有在本类中才可以用

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

提供"get变量名()"方法，用于获取成员变量的值，方法用public修饰
提供set变量名(参数)方法，用于设置成员变量的值，方法用public修饰

两个地方

第一个
public class Student {
    String name;
    private int age;
    public void setAge(int a){
        if(a<0 || a>120){
            System.out.println("gg!");
        }else{
            age=a;
        }
    }
    public int getAge(){
        return age;
    }
    public void show(){
        System.out.println(name+":"+age);
    }
}
第二个
public class hello {
    public static void main(String[] args) {
        Student s=new Student();
        //使用对象
        s.name="ll";
        s.setAge(777);
        s.show();
    }
}

多次使用

第一个
public class Student {
    private String name;
    private int age;
    public void setName(String a){
        name=a;
    }
    public String getName(){
        return name;
    }
    public void setAge(int b){
        age=b;
    }
    public int getWidth(){
        return age;
    }

    public void show(){
        System.out.println(name+":"+age);
    }
}
第二个
public class hello {
    public static void main(String[] args) {
        Student s=new Student();
        //使用对象
        s.setName("llll");
        s.setAge(777);
        s.show();
    }
}

还可以进行

System.out.println(s.getName()+"----"+s.getWidth());

封装

this指的是成员变量

demo

接上
public class Student {
    private String name;
    private int age;
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getWidth(){
        return age;
    }

    public void show(){
        System.out.println(name+":"+age);
    }
}

面向对象的三大特征

封装、继承、多态

是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作的

封装的原则

将类的某些信息隐藏在内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和控制

成员变量private，提供对应的getxxx()和setXxx()方法

封装的好处

构造方法

CTRL+alt+L对idea的代码进行格式化

public Student(){
	 System.out.println("无")
}
然后另一个去调用
Student s=new Student();
就会出现
无

public Student(String name){
	this.name=name
}
然后构造就行了
第二个
直接
Student s2=new Student("李");
s2.show();
还可以进行这样
public Student(String name,int age){
	this.name=name;
	this.age=age;
}
然后
Student s3=new Student("李",12);
s3.show();

标准类的制作

1.成员变量

使用private修饰

构造方法

提供一个无参数构造方法

提供一个带有多个参数的构造方法

成员方法

提供每一个成员变量对应的SetXxx()/getXxx()

提供一个显示对象信息的show()

创建对象并为其成员变量赋值的两种方法

无参数构造方法创建对象后使用setXxx()赋值

使用带参构造方法直接创建带有属性值的对象

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + " : " + age);
    }
}

public class hello {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("路");
        s1.setAge(88);
        s1.show();
        Student s2 = new Student("李",33);
        s2.show();
    }
}

API

应用程序编程接口

java api指的就是jdk中提供的各种功能的java类

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串数据");
        String line=sc.nextLine();
        System.out.println(line);
    }
}

字符串创建之后，是不可以更改的

String类在java.lang包下，所以使用的时候不需要导包

字符串特点：

字符串不可改变，他们的值在创建后

Scanner sc=new Scanner(System.in);
String line=sc.nextLine();

字符串不可改变，他们的值在创建后不可以被更改

虽然String的值不可逆，但特们可以被共享

String的构造方法

直接赋值最好

字符串的比较

equals()

public class hello {
    public static void main(String[] args) {
        String s1="abc";
        String s2="abc";
        System.out.println(s1.equals(s2));
    }
}

习题

用户登录

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        String username = "stage";
        String password = "stage";
        for (int i = 0; i < 3; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入账户");
            String name = sc.nextLine();
            System.out.println("请输入密码");
            String pass = sc.nextLine();
            if (name.equals(username) && pass.equals(password)) {
                System.out.println("you are right");
                break;
            } else {
                if (2 - i == 0) {
                    System.out.println("gg");
                } else {
                    {
                        System.out.println("lose!   " + i);
                    }
                }
            }
        }
    }}
主要使用了equals来进行比较和for循环的嵌套

遍历字符串

快捷键

字符串的

先输入字符串的sc.nextLine();然后按键盘ctrl+alt+v

自动生成左边的string

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("输入");
        String line = sc.nextLine();
        System.out.println(line.charAt(0));
        System.out.println(line.charAt(1));
        System.out.println(line.charAt(2));
    }
}
这个也可
for (int i=0;i<line.length();i++){
            System.out.println(line.charAt(i));
        }

统计字符次数

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("字符串");
        String line = sc.nextLine();
        int bigcount = 0;
        int smallcount = 0;
        int numbercount = 0;
        for (int i = 0; i < line.length();i++){
            char ch=line.charAt(i);
            if(ch>='A'&&ch<='Z'){
                bigcount++;
            } else if (ch >= 'a' && ch <= 'z') {
                smallcount++;
            }else {
                numbercount++;
            }
        }
        System.out.println(bigcount+","+smallcount+","+numbercount);
    }
}

拼接字符串

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        int [] arr={1,2,3};
        String s=arrytostring(arr);
        System.out.println(s);
    }
    public static String arrytostring(int [] arr){
        String s="";
        s+="[";
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                s+=arr[i];
            }
            else{
                s+=arr[i];
                s+=",";
            }
        }
        s+="]";
        return s;
    }
}

字符串反转

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("is!");
        String line = sc.nextLine();
        String line1=arrary(line);
        System.out.println(line1);
    }
    public static String arrary(String s){
        String ss="";
        for(int i=s.length()-1;i>=0;i--){
            ss+=s.charAt(i);
        }
        return ss;
    }
}

stringbulid

构造

public class hello {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder("Hello");
        System.out.println(sb);
        System.out.println(sb.length());
    }
}

添加内容

public class hello {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        sb.append("hello");
        sb.append(100);
        System.out.println(sb);
    }
}
还可以链式
   		sb.append(100).append("nihao");
反转
    直接
    sb.reverse();

bulider和string相互转换

为什么转？

因为bulider有两个好用的方法，reverse，append

string不能直接使用

所以得转换

转换

bulider转换为string
public class hello {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        sb.append("hello");
        String s=sb.toString();
        System.out.println(s);
    }
}

string转换为bulider
public class hello {
    public static void main(String[] args) {
        String s="hello";
        StringBuilder ss=new StringBuilder(s);
        System.out.println(ss);
    }
}

字符串拼接

public class hello {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        String sss = arra(arr);
        System.out.println(sss);
    }
    public  static String arra(int[] arr){
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        String ss=sb.toString();
        return ss;
    }
}

字符串反转

import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("string？");
        String line = sc.nextLine();
        String line1=reverse(line);
        System.out.println(line1);
    }
    public static String reverse(String s){
        StringBuilder sb=new StringBuilder(s);
        sb.reverse();
        String ss=sb.toString();
        return ss;
    }
}

Arraylist

集合类的特点：

提供一种存储空间可变的存储，存储的数据容量可以发生改变

集合类有许多

先学arraylist

import java.util.ArrayList;
public class hello {
    public static void main(String[] args) {
        ArrayList<String> arr=new ArrayList<String>();
        System.out.println(arr);
    }
}
添加元素
arr.add("aaaaa");
在指定位置上添加索引和字符串
arr.add(1,"aaaa");
但是前面的索引不能越界

操作

arr.remove("aaa");
arr.remove(1);
当然删除索引也不能越界
arr.set(1,"javaee");
返回指定索引
sout    arr.get(0);
返回数组大小
sout    arr.size();

遍历字符串

import java.util.ArrayList;
public class hello {
    public static void main(String[] args) {
        ArrayList<String> arr=new ArrayList<String>();
        arr.add("stage");
        arr.add("qwer");
        System.out.println(arr.get(0));
        for(int i=0;i< arr.size();i++){
            String s=arr.get(i);
            System.out.println(s);
        }
    }
}

存储学生对象并遍历

第一个
public class Student {
    private String name;
    private int age;
    public Student(){

    }
    public Student(String name, int age){
        this.name = name;
        this.age= age;
    }
    public void setName(String name){
        this.name= name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age= age;
    }
    public int getAge(){
        return age;
    }
}
第二个
import java.util.ArrayList;
public class hello {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> arrary=new ArrayList<Student>();
//        创建学生对象
        Student s1=new Student("梨花",88);
        Student s2=new Student("户沙雕",454);
        arrary.add(s1);
        arrary.add(s2);
        for(int i=0;i<arrary.size();i++){
            Student s=arrary.get(i);
            System.out.println(s.getName()+s.getAge());
        }
    }
}

升级版本

import java.util.ArrayList;
import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> arr = new ArrayList<Student>();
        addStudent(arr);
        addStudent(arr);
        addStudent(arr);
        for (int i = 0; i < arr.size(); i++) {
            Student s = arr.get(i);
            System.out.println(s.getName() + s.getAge());
        }
        /*Scanner sc=new Scanner(System.in);
        System.out.println("name:");
        String name = sc.nextLine();
        System.out.println("age:");
        String age=sc.nextLine();
//        创建学生对象
        Student s=new Student();
        s.setName(name);
        s.setAge(age);
//        往集合中添加对象
        arr.add(s);
        */
//        为了调高代码的利用，用方法

    }

    public static void addStudent(ArrayList<Student> arr) {
        Scanner sc = new Scanner(System.in);
        System.out.println("name:");
        String name = sc.nextLine();
        System.out.println("age:");
        String age = sc.nextLine();
//        创建学生对象
        Student s = new Student();
        s.setName(name);
        s.setAge(age);
//        往集合中添加对象
        arr.add(s);
    }
}第一个
public class Student {
    private String name;
    private String age;
    public Student(){

    }
    public Student(String name, String age){
        this.name = name;
        this.age= age;
    }
    public void setName(String name){
        this.name= name;
    }
    public String getName(){
        return name;
    }
    public void setAge(String age){
        this.age= age;
    }
    public String getAge(){
        return age;
    }
}
第二个
import java.util.ArrayList;
import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> arr = new ArrayList<Student>();
        addStudent(arr);
        addStudent(arr);
        addStudent(arr);
        for (int i = 0; i < arr.size(); i++) {
            Student s = arr.get(i);
            System.out.println(s.getName() + s.getAge());
        }
        /*Scanner sc=new Scanner(System.in);
        System.out.println("name:");
        String name = sc.nextLine();
        System.out.println("age:");
        String age=sc.nextLine();
//        创建学生对象
        Student s=new Student();
        s.setName(name);
        s.setAge(age);
//        往集合中添加对象
        arr.add(s);
        */
//        为了调高代码的利用，用方法

    }

    public static void addStudent(ArrayList<Student> arr) {
        Scanner sc = new Scanner(System.in);
        System.out.println("name:");
        String name = sc.nextLine();
        System.out.println("age:");
        String age = sc.nextLine();
//        创建学生对象
        Student s = new Student();
        s.setName(name);
        s.setAge(age);
//        往集合中添加对象
        arr.add(s);
    }
}

学生管理系统

快捷键alt+insert快速进行构造类和方法

 System.exit(0);
//                    退出jvm虚拟机

第一个

public class Student {
    private String sid;
    private String name;
    private String age;
    private String address;

    public Student() {
    }

    public Student(String sid, String name, String age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

第二个

import java.util.ArrayList;
import java.util.Scanner;

public class hello {
    public static void main(String[] args) {
//        创建一个学生对象，用于存储学生数据
        ArrayList<Student> array = new ArrayList<Student>();
        while (true) {
            System.out.println("---student manage---");
            System.out.println("1.添加学生");
            System.out.println("2.删除学生");
            System.out.println("3.修改学生");
            System.out.println("4.查看所有");
            System.out.println("5.推出系统");
            System.out.println("your choice is ");
            Scanner sc = new Scanner(System.in);
            String line = sc.nextLine();
            switch (line) {
                case "1":
                    addStudent(array);
                    break;
                case "2":
                    deleteStudent(array);
                    break;
                case "3":
                    updateStudent(array);
                    break;
                case "4":
                    findAllStudent(array);
                    break;
                case "5":
                    System.out.println("谢谢使用！");
                    System.exit(0);
//                    退出jvm虚拟机


            }
        }
    }

    public static void addStudent(ArrayList<Student> array) {
        Scanner sc = new Scanner(System.in);
//        为了让sid在外能被访问到，所以定义在外面
        String sid;
        while(true) {
            System.out.println("学号 is");
            sid = sc.nextLine();
            boolean flag = isUsed(array,sid);
            if (flag) {
                System.out.println("not found!");
            }else {
                break;
            }
        }
        System.out.println("姓名 is");
        String name = sc.nextLine();
        System.out.println("年龄 is");
        String age = sc.nextLine();
        System.out.println("居住地 is");
        String address = sc.nextLine();
        Student s = new Student();
//        创建学生对象，把键盘录入的数据给学生对象的成员变量
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);
        array.add(s);
        System.out.println("successful!");

    }
    public static boolean isUsed(ArrayList<Student> array,String sid){
        boolean flag = false;
        for(int i=0;i<array.size();i++){
            Student s=array.get(i);
            if(s.getSid().equals(sid)){
                flag = true;
                break;
            }
        }
        return flag;
    }

    public static void findAllStudent(ArrayList<Student> array) {
        if (array.size() == 0) {
            System.out.println("无信息，请先输入");
            return;
        }
        System.out.println("学号\t姓名\t年龄\t居住地");
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getSid() + "\t" + s.getName() + "\t" + s.getAge() + "\t" + s.getAddress());

        }
    }

    public static void deleteStudent(ArrayList<Student> array) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入要删除的学生的学号:");
        String sid = sc.nextLine();
        int index = -1;
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            if (s.getSid().equals(sid)) {
                index = i;
                break;
            }
        }
        if (index == -1) {
            System.out.println("not found!");
        } else {
            array.remove(index);
            System.out.println("goof@!");
        }
    }

    public static void updateStudent(ArrayList<Student> array) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学号:");
        String sid = sc.nextLine();
        System.out.println("new name is ");
        String name = sc.nextLine();
        System.out.println("new age is ");
        String age = sc.nextLine();
        System.out.println("new address is ");
        String address = sc.nextLine();
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);
        for (int i = 0; i < array.size(); i++) {
            Student student = array.get(i);
            if (student.getSid().equals(sid)) {
                array.set(i, s);
                break;
            }
        }
        System.out.println("good!");
    }
}

标签：java,String,int,System,笔记,初学,println,public,out
来源： https://www.cnblogs.com/chenyouxiu/p/16054203.html