ArrayList如何储存基本类型:
只能存储引用类型,不能写,但是存储基本类型我们可以选择它的包装类,也就是把基本类型的首字母改成大写,除了int 和char类型:int=Integer,char=Character
public class Demo {
public static void main(String[] args) { ArrayList<Integer> integers=new ArrayList<>(); integers.add(1);
integers.add(3);
integers.add(4);
integers.add(5);
System.out.println(integers);
}
}
数组添到集合:
生成6个1-33之间的随机数字添加到集合中,并遍历一下:
public class Demo {
public static void main(String[] args) {
//创建我们随机数对象 Random random=new Random();
//创建一个集合的对象
ArrayList<Integer> arrayList=new ArrayList<>(); //添加随机数到集合
for (int i = 0; i <6; i++) { intr=random.nextInt(33)+1;
arrayList.add(r);
}
for (int i = 0; i <arrayList.size() ; i++) { System.out.println(arrayList.get(i));
}
}
}
定义获取所有偶数的集合方法,(ArrayList作为方法的返回值)
public class Demo {
public static void main(String[] args) {
//定义获取所有偶数元素的集合的方法(ArrayList作为我们方法的返回值)
//创建随机数的对象
Random random=new Random();
//创建我们的ArrayList集合
ArrayList<Integer> arrayList=new ArrayList<>(); //添加我们的随机数到集合中
for (int i = 0; i <30; i++) {
int r=random.nextInt(300)+1;
arrayList.add(r);
}
ArrayList<Integer> arrayList1 = getArrayList(arrayList); System.out.println(arrayList1);
}
public static ArrayList<Integer> getArrayList(ArrayList<Integer> arrayList){
//再创建一个集合存放我们的偶数 ArrayList<Integer> arrayList1=new ArrayList<>();
//遍历我们方法传过来的集合
for (int i = 0; i <arrayList.size() ; i++) {
//判断为偶数,添加到我们的新创建的集合中 Integer num=arrayList.get(i);
if(num%2==0){
arrayList1.add(num);
}
}
return arrayList1;
}
}
String类:
String类代表字符串。
java程序中的所有字符串文字(例如“abc”)都被实现为此类的实例。字符串不变
String类包括用于检查序列的各个字符的方法,用于比较字符串,搜索字符串,提取字符串以及创建所有的字符翻译为大写或小写的字符串的副本。
特点:字符串不变,字符串的值在创建后就不会发生变化:
String s1="abs";
s1+="sd";
System.out.println(s1)
//内存中两“abs”,“abssd”两个对象,刚开始s1指向的是我们的“abs”,拼接完以后,我们s1就指向了新的地 址“abssd
因为String对象是不可变得,所以它可以被共享,String类的底层就是靠我们的字符组实现的所以不需要导包。
public class Demo {
public static void main(String[] args) {
//无参构造创建一个字符串对象
String str=new String();
//通过传字符数组构造字符串对象 char[] charArr={'a','b','c'};
String str1=new String(charArr); System.out.println(str1);
//通过字节数组构造
byte[] bytes={97,98,99};
String str3=new String(bytes); System.out.println(str3);
}
}
获取功方法:
public int length();返回此字符串的长度
public String concat(Sring str):将指定的字符串连接到我们该字符串的尾部
public char charAt(int index);返回指定索引处char的值
public int indexOF(String str);返回指定字符串第一次出现在该字符串内的索引
public String subString (int index);返回一个字符串,从index开始截取字符串到字符串尾部
public String subString(int begin, int end):返回一个子字符串,从begin开始到结束,包含begin,但是包含我们的end,
public class Demo {
public static void main(String[] args) {
//创建几个字符串
String str1="hello1212";
String str2="hello2323";
String str3="HELLO2324";
//equals方法,比较两个字符串是否相同
System.out.println(str1.equals(str2));
System.out.println(str1.equals(str3));
//equalsIgnoreCase方法,比较两个字符串是否相同,忽略大小写 System.out.println(str1.equalsIgnoreCase(str3));
//返回字符串的长度
System.out.println(str1.length());
//将指定字符串拼接到我们该字符串的尾部
System.out.println(str1.concat("123345"));
//返回指定索引处的
char System.out.println(str1.charAt(2));
System.out.println(str1.indexOf("12"));
System.out.println(str1.substring(3));
System.out.println(str1.substring(3,6));
}
}
转换功能的方法:
public char [] toCharArray();将字符串转换为新的字符串组
public byte [] getBytes();使用平台默认的字符集合,将该字符串编码转化为新的自己玩数组:
public class Demo {
public static void main(String[] args) {
//创建一个字符串对象
String s="abcde";
//将我们字符串转换字符数组 char[] chars=s.toCharArray();
for (int i = 0; i <chars.length ; i++) { System.out.println(chars[i]);
}
byte[] bytes=s.getBytes();
for (int i = 0; i <bytes.length; i++) { System.out.println(bytes[i]);
}
String str="itujiuye";
String replace=str.replace("it","IT"); System.out.println(replace);
}
}
分割的方法:
String类练习:
1、定义一个方法,把数组{1,2,3}按照指定的给是拼接成一个字符串: 格式:【元素#元素#元素】 2、键盘录入一个字符串,统计字符串中大小写字母的个数以及数字字符的个数:
public class Demo {
public static void main(String[] args) {
//把数组{1,2,3}按照指定的给是拼接成一个字符串:格式:【元素#元素#元素】
int[] arr={1,2,3}; String string = arrayToString(arr); System.out.println(string);
}
//返回值是一个字符串String
//参数类型:int类型数据
private static String arrayToString(int[] arr) {
//创建一个开始的字符串
String str="【";
//遍历数组拼接
for (int i = 0; i <arr.length ; i++) {
if(i==arr.length‐1){
str=str.concat(arr[i]+"】");
}else{
str=str.concat(arr[i]+"#");
}
}return str;
}
}
public class Demo {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
//键盘录入字符串
System.out.println("请输入一个字符串:");
String str=scanner.nextLine();
int bigCount=0;
int smallCount=0;
int numberCount=0;
//遍历我们的字符串
for (int i = 0; i <str.length() ; i++) {
char ch=str.charAt(i);
if(ch>='A'&&ch<='Z'){ bigCount++;
}else if(ch>='a'&&ch<='z') {
smallCount++;
}else if(ch>='0'&&ch<='9'){
numberCount++;
}else{
System.out.println("该字符是一个非法字符!"+ch);
}
}
System.out.println("大写字符:"+bigCount);
System.out.println("小写字符:"+smallCount); System.out.println("数字字符:"+numberCount);
}
}
static关键字;
概述:
关于我们static关键字的使用,他可以修饰我们成员变量和成员方法,被修饰的成员属于类,而不是单单一个类的,既然static这个修饰的东西属于类,name调用的时候,就不需要创建对象去调用。
类变量:
当static修饰我们的成员变量的时候,改变量属于类,该类每个对象都共享一个类的值,任何对象都可以个更改变量的值,但是可以在不创建对象的情况对类变量进行操作。
类变量:
public class Student {
//学生的姓名
private String name;
//学生的年龄
private int age;
//学生的学号
private int sid;
//类变量,记录学生的数量,分配学号
public static int numberStudent=0;
public Student(String name, int age) {
this.name = name;
this.age = age;
this.sid = ++numberStudent;
}
@Override
public String toString() {
return "Student{" + "name='" + name + '\'' + ", age=" + age + ", sid=" + sid + '}';
}
}
静态方法:
当static修饰我问的成员方法的时候,该方法称为类方法,静态方法在申明的时候用static,建议使用的使用,直接用我们的类名.方法名。
调用我们的类方法,直接用:
类名.方法名();
注意事项:
1、静态方法可以访问我们的静态变量和静态方法
2、静态方法不能直接访问我们的成员变量和成员方法,反之,成员方法可以直接访问我们的静态变量和静态方法。
3、静态方法不能使用this关键字。
总结:静态的东西随着类的加载而加载,优于对象存在。静态方法只能访问静态成员。
1、随着类的加载而加载,而且只加载一次。
2、存储在我们固定区域(静态区),可以直接使用类名调用
3、它优于对象存在,所以,所有对象共享。
静态代码块:
格式:
static{
代码块
}
位置:类中方法外
执行;随着类的加载而执行一次且只有一次,优于我们main方法和我们构造方法执行。
public class Game {
//类变量
public static int number;
public static ArrayList<String> list;
//初始化
static {
//给类变量赋值
number=2;
list=new ArrayList<>();
list.add("abc");
list.add("小白"); }
public static void main(String[] args) { System.out.println(Game.number);
}
}
static关键字,可以修饰变量,方法和代码块,在使用过程中,其中目的就是不创建对象直接去调用。