数组概念
数组可以将多个变量进行统一的命名，这样相同类型的元素按照一定的顺序排序。在JAVA中，数组属于引用数据类型，所以在数组的操作中，也会涉及到内存的分配问题。
声名并开辟数组
/*
数据类型 数组名称 [] = new 数据类型 [长度]
数据类型 数组名称 [] = new 数据类型 []{值1，值2....}
*/
public class Text{
public static void main(String args[]){
int arrayInt [] = new int [3]; //动态初始化，先开辟数组空间，再为数组中的内容赋值
arrayInt[0] = 1;
arrayInt[1] = 2;
arrayInt[2] = 3;
int int1 [] = new int [] {1,2,3,4}; //静态初始化
for (int i = 0; i < arrayInt.length; i++){
System.out.println(i);
}
}
}二维数组
public class Text{
public static void main(String args[]){
int int1 [][] = new int [] [] {
{1,2},{3,4},{5,6}
};
for (int i = 0; i < int1.length; i++){
for(int j = 0; j < int1[i].length; j++){
System.out.print(int1[i][j] + "\t");
}
}
}
}数组与方法参数的传递
数组也是引用数据类型，那么也可以通过方法进行参数传递及返回。
public class Text{
public static void main(String args[]){
int i1 [] = new int []{1,2,3};
int i2 [] = add(i1);
for(int i = 0; i < i2.length; i++){
System.out.println(i2[i]);
}
}
public static int [] add(int int1[]){
for(int i = 0; i < int1.length; i++){
int1[i] = int1[i] * 2;
}
return int1;
}
}数组常用方法
数组复制
数组复制可以将一个数组的部分内容复制到另一个数组之中。
/*
System.arraycopy(源数组名称,源数组复制开始索引,目标数组名称,目标数组复制开始索引,长度);
*/
public class Text{
public static void main(String args[]){
int i1 [] = new int []{1,2,3};
int i2 [] = new int []{4,5,6};
System.arraycopy(i1,1,i2,0,2);
for(int i = 0; i < i2.length; i++){
System.out.println(i2[i]); // 2,3,6
}
}
}数组排序
此方法排序只适合基本数据类型
/*
java.util.Arrays.sort(数组名称);
java.util是一个java的系统包名称，Arrays是一个系统提供的类
*/
public class Text{
public static void main(String args[]){
int i1 [] = new int []{1,3,2,7,6,9,0};
java.util.Arrays.sort(i1);
for(int i = 0; i < i1.length; i++){
System.out.println(i1[i]); // 2,3,6
}
}
}对象数组
数组不仅可以保存基本数据类型，也可以保存引用数据类型，也就是说数组可以保存String、对象等引用数据数据类型。
对象数据的最大好处是将多个对象统一进行管理
/*
类名称 对象数组名称 [] = new 类名称 [长度]
类名称 对象数组名称 [] = new 类名称 [] {实例化对象,实例化对象,......}
*/
class Book{
private String title;
private Double price;
/*
setter和getter省略
*/
public Book(){}
public Book(String s, Double b){
title = s;
price = b;
}
public String getInfo(){
return "title:" + title + "\t price:" + price;
}
}
public class Text{
public static void main(String args[]){
Book b1 [] = new Book []{
new Book("JAVA",54.2),
new Book("PHP",34.2),
new Book("PYTHON",46.8)
};
for (int i = 0; i < b1.length; i++){
System.out.println(b1[i].getInfo());
}
}
/*
title:JAVA price:54.2
title:PHP price:34.2
title:PYTHON price:46.8
*/
}String类匿名对象
任何编程语言都没有提供字符串数据类型的概念，同样在JAVA里也是通过使用char数组来保存字符串的定义。
String是用来定义字符串类型，它不属于基本数据类型，是一个特殊的引用数据类型。
String s1 = "你好"; //String类的匿名对象
String str = new String("hello"); //利用构造方法进行实例化那么这两种实例化有什么区别呢？
String匿名对象的数据保存在JVM底层的一个对象池，当有新的String匿名对象设置了同样的内容后，将不会开辟新的内存空间，而是使用已有的对象进行引用分配，也就说是共享的。
而利用new关键字会开辟一个新的内存空间保存该值，不管该值是否相同，都将会开辟新内存空间进行保存。
所以使用String匿名对象可以节约内存空间
String类常用方法
- String.charAt()：返回char指定索引处的值
String s1 = "hello";
System.out.print(s1.charAt(1)); //e- String.leng()：返回字符串长度
- String.isEmpty()：判断字符串是否为空或0
- String.getBytes()：将字符串转换为字节数组
String s1 = "hello";
byte b1 [] = s1.getBytes();
for (byte b : b1) {
System.out.print(b + "\t");//104 101 108 108 111
}- String.equals()：字符串比较
- String.startsWith()：是否以指定字符串开头
- String.startsWith()：是否以指定字符串结尾
- String.indexOf()：返回指定字符串第一次出现的索引
- String.lastIndexOf()：返回指定字符串最后一次出现的索引
- String.substring()：不用多说了吧，sql注入中常用到
- String.concat()：连接字符串，相当于s1+s2
- String.replace()：替换字符串
- String.replaceAll()：替换满足条件的所有字符串
- String.split()：分割字符串
- String.join()：以指定符号连接字符串
- String.trim()：删除首尾空格
- String.toCharArray()：转换为字符数组
更多详情请查看JDK文档
this关键字
this可以完成三件事：调用本类属性、调用本类方法、表示当前对象。
调用本类属性
class Book{
private String title;
private Double price;
/*
setter和getter省略
*/
public Book(){}
public Book(String title, Double price){
this.title = title; //this.属性名，调用本类属性
this.price = price;
}
public String getInfo(){
return "title:" + this.title + "\t price:" + this.price;
}
}调用本类方法
- 调用本类普通方法：this.方法()
- 调用本类构造方法：this()
class Book{
private String title;
private Double price;
/*
setter和getter省略
*/
public Book(){}
public Book(String title){
this();
this.title = title;
}
public Book(String title, Double price){
this(title);
this.price = price;
}
public String getInfo(){
return "title:" + this.title + "\t price:" + this.price;
}
}注意！使用this()调用构造方法时只能放在构造方法的首行
进行构造方法互相调用时，一定要保留出口
表示当前对象
class Book{
public void print(){
System.out.print(this + "\n");
}
}
public class Text{
public static void main(String args[]){
new Book().print();//Book@15615099
new Book().print();//Book@1edf1c96
}
}static关键字
使用static定义属性和方法，那么该属性和方法就是公共的
定义属性
//使用static修饰属性后，这个属性将成为公共属性，任何一个对象修改了此属性的内容都会影响其它对象。
class Book{
static String title;//使用static修饰属性
public void getinfo(){
System.out.print(this.title);
}
}
public class Text{
public static void main(String args[]){
Book.title = "JAVA";//则不需要实例化就可修改
new Book().getinfo(); //JAVA
}
}JAVA内存空间
- 栈内存：保存所有对象引用的堆内存空间地址
- 堆内存：保存每个对象的具体属性内容
- 全局数据区：保存static类型的属性
- 全局代码区：保存所有方法定义
所以定义方法也是同样的道理，可以不实例化直接通过：类名称.方法进行调用
代码块
普通代码块
把一个代码块写到方法里，就是普通代码块。主要用于变量名重名问题。
public class Text{
public static void main(String args[]){
{
int num = 2; //局部变量
}
int num = 10; //全局变量
}
}构造块
将一个代码块写到一个类中，就是构造块。构造块在每一次实例化对象时都会被调用，且优先于构造方法执行。
class Book{
public Book(){};
{
System.out.print("类中的构造块");
//构造块
}
}静态块
如果一个代码块用static定义，就是静态块。在类中定义，那么当有多个实例化对象时，静态块会优先调用，且只调用一次，主要作用是为static属性做初始化。
如果在主类中使用，则优先于主方法main()执行。
内部类
是指在一个类的内部继续定义其它内部结构类
class Book{
private String title = "JAVA";
class Book1{
public void print(){
System.out.print(title);
}
}
public void fun(){
new Book1().print();
}
}
//使用内部类最大的好处是可以轻松访问外部类中的私有属性，一般很少使用。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
