java基础day6#ArrayList存储基本类型数据类型#String类

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关键字，可以修饰变量，方法和代码块，在使用过程中，其中目的就是不创建对象直接去调用。