首页 > 编程语言 >Java基础-String字符串和数组

Java基础-String字符串和数组

时间：2024-02-27 17:36:01浏览次数：30  
标签：Java String int 元素 数组 字符串 public

1. String基础：

字符串是编程时经常用到的一种数据类型。Java中使用String类和StringBuilder类来封装字符串。String类定义不变字符串，StringBuffer类则用于可变字符串处理。换句话说，String类创建的字符串时不会改变的，而StringBuffer类创建的字符串可以修改。

字符串的声明与创建：

1. 声明字符串的格式如下：

String stringName;

2. 字符串的创建可以有以下两种方法。

使用字符串构造方法，字符串的构造方法又如下四个：

public String();                  //创建一个空的字符串
public String(String str);        //用已有字符串创建新的字符串
public String(StringBuffer str);  //用StringBuffer对象的内容初始化新字符串
public String(char value[]0);     //用已有字符数组初始化新的字符串

使用赋值语句。也可以使用赋值语句创建String类型变量并赋值。

String str = "Student";

  1. 上面语句与使用构造方法创建字符串变量等价。

  2. 这里需要注意的是，字符串常量在Java中是以对象形式存储的，Java编译时将自动为每个字符串常量创建一个对象。因此将字符串常量传递给字符串变量时，Java编译器自动将常量对应的对象传递给字符串变量，因此下面的两条语句中，两个字符串变量str1和str2均指向同一个内存空间。

    • String str1 = "Student";
    • String str2 = "Student";

2. String类的要点：

  1. String类又被称作不可变字符序列。
  2. String类位于java.lang包中，Java程序默认导入java.lang包下的所有类。
  3. Java字符串就是Unicode字符序列，例如字符串"Java"就是4个Unicode字符组成。
  4. Java中没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每个用双引号引起来的字符串都是String类的实例。
  5. java允许使用符号“+”把两个字符串连接起来。

3. 字符串类String的主要方法：

1. 获取字符串长度：

可以使用字符串.length()的形式来获得字符串的长度。
public int length();

int length = "abc".length();//返回3

2. 截取一个字符：

该方法返回指定索引处的char值。索引范围从0到length()-1.字符串的第一个char值在索引0处，第二个在索引1处，以此类推。
public char charAt();

char ch = "abc".charAt(1);//返回'b'

3. 取得子串：

public String substring(int beginIndex);
public String substring(int beginIndex,int endIndex);

诀窍：取前不取后，length = endIndex-beginIndex;

"unhappy".substring(2);     //happy
"smiles".substring(1,5);    //mile

4. 字符产相等比较：

  1. public boolean equals(String str);

字符串对象调用String类的equals方法，比较当前字符串对象是否与参数制定的字符串str对象相同。

String str1 = "Hello";
String str2 = new String("Hello");
str1.equals(str2);//返回true
  1. public boolean equalsIgnoreCase(String anotherString);

忽略大小写进行内容的比较

"hello".equalsIgnoreCase("Hello");  //true
  1. 需要注意的是，==运算符比较两个对象是否引用同一实例。
 String str1 = "Hello";  //地址值0x5678
String str2 = "Hello";  //地址值0x5678
String str3 = new String("Hello");  //地址值0x6789
boolean bool1 = (str1 == str2); //true
boolean bool2 = (str1 == str3); //false
str1.equals(str3);  //true

5. 字符串连接：

public String concat(String str);

该方法将指定字符串串联到此字符串的结尾。如果参数字符串的长度为0，则返回此String对象。

"Tom".concat("&Jerry");//返回Tom&Jerry
String str = "567"+"和789";//返回567和789

6. 字符串内容比较：

  1. public int compareTo(String anotherString);

按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值。

将此String对象表示的字符序列与参数字符串所表示字符序列进行比较。

如果按字典顺序此String对象在参数字符串之前，则比较结果为一个负整数。反之为正整数。如果这两个字符串相等，则结果为0.

compareTo只有在方法equals(Object)返回true时才返回0

  1. 除此之外，java还提供了不考虑大小写的字典顺序比较方法，

public int compareToIgnoreCase(String str);

例如：

String s1 = "abc";
String s2 = "ABC";
String s3 = "acb";
String s4 = "abc";
System.out.println(s1.compareTo(s2));   //返回32
System.out.println(s1.compareTo(s3));   //返回-1
System.out.println(s1.compareTo(s4));   //返回0
System.out.println(s1.compareToIgnoreCase(s2)); //返回0

7. 字符串检索：

字符串检索是指确定一个字符串是否包含某一个字符或子字符串，如果包含则返回其位置;如果没有，则返回负数。

public int indexOf(int ch);
public int indexOf(int ch,int fromIndex);
public int indexOf(String stringName2);
public int indexOf(String stringName2,int fromIndex);

String s1 = "I love java";
System.out.println(s1.indexOf('a'));        //返回8
System.out.println(s1.indexOf('j',2));      //返回7
System.out.println(s1.indexOf("love"));     //返回2
System.out.println(s1.indexOf("love",9));   //返回-1

8. 去掉起始和末尾的空格：

trim()返回删除字符串起始和结尾的空格后的字符串，如果没有起始和结束空格，则返回此字符串。

public String trim();

String s= " this is a demo of the trim method.";
String s1 = s.trim();   //s1 = "this is a demo of the trim method.";

9. 字符串替换：

public String repalce(char oldChar,char newChar);

例如：

String s = "the war of baronets".replace('r','y');  //s = "the way of bayonets";

10. 字符串大小写转换：

  1. public String toLowerCase();

将字符串中的所有字符全部小写

String s = "I Love Java".toLowerCase(); //s = "i love java";
  1. public String toUpperCase();

将字符串中的所有字符全部大写

String s = "I Love Java".toUpperCase(); //s = "I LOVE JAVA";

11. 将其他数据类型转换为字符串：

public static String valueOf(boolean bool);
public static String valueOf(char c);
public static String valueOf(int i);
public static String valueOf(long l);
public static String valueOf(float f);
public static String valueOf(double d);

另外，Object类的toString方法也可以实现其他数据类型转换为字符串。例如：

String s = Double.toString(12.8);   //s = "12.8";
String s = String.valueOf(12.8);    //s = "12.8";
String s = String.valueOf(true);    //s = "true";

需要注意的是，Object类的toString方法返回该对象的字符串表示。通常，toString方法会返回一个以文本方式表示此对象的字符串。结果应简明但易于读懂。

12. 字符串的分隔：

public String[] split(String regex);
public String[] split(String regex,int limit);

例如：

String message = "I Love Java";
String[] split = message.split(" ");    //返回一个数组包含["I","Love","Java"];

4. StringBuffer类的主要方法：

String类和StringBuffer类都可以存储和操作字符串，即包含多个字符的字符串数据。String类是字符串常量，是不可更改的常量。而StringBuffer是字符串变量，他的对象是可以扩充和修改的。

  1. 常用的StringBuffer的构造方法：
StringBuffer(String str);//构造一个字符串缓冲区，并将其内容初始化为指定过的字符串内容。
  1. 主要操作有：append方法和insert方法

append方法每次只能添加字符串在末端，而insert方法可以在指定的位置进行插入。

两个方法都可以进行重载，将不同类型的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。

String str = "start";
str.append("le");   //返回"startle"
str.insert(4,"le"); //返回"starlet"

5. 数组

数组就是相同类型的数据按顺序组成的一种复合数据类型，每个数据成为一个数据元素，用下标来表示同一数组中的不同数组元素，使用时可以哦通过数组名和下标访问数组中的元素，其下表从0开始。

数组的特点如下:

  1. 一个数组中的元素的数据类型应该是相同的。
  2. 数组中的各个元素是有序的，他们在内存中是按照先后顺序连续存放在一起的。
  3. 每个数组元素用其所在数组的名字和数组下标来确定。
  4. 数组的下标是从0开始的，数组的长度是指其所包含的数组元素的个数。

Java提供数组类型，数组元素可以是简单数据类型，也可以是引用数据类型(对象或数组)。

如果是基本数据类型，则为一维数组。数组元素仍为数组的是多维数组。Java的数组元素是引用数据类型，数组的使用步骤应该是：声明--创建--初始化--使用。

1. 一维数组：

1. 一维数组的声明：

声明一维数组的格式有如下两种：

  1. 数组元素类型[] 数组名;
  2. 数组元素类型 数组名[];

数组声明的时候，Java没有给数组进行分配空间，仅仅创建了一个引用数组的存取地址。

数组的声明的目的只是告诉系统一个新的数组的名称和类型，数组本身不能存放任何数组元素，现阶段的数组值为null。

因此，使用数组之前，需要先使用new关键字创建数组，为数组分配指定长度的内存空间。

2. 数组的创建：

为数组进行分配空间的格式如下：

数组名 = new 数组元素的类型[数组的长度];

例如：double array = new double[10];//创建了一个长度为10的数组，并分配了内存空间

这样，就给数组array分配了长度为10的内存空间，用来保存10个double类型的数据。

3. 数组的初始化：

数组创建之后，若不对数组进行初始化，系统会自动根据其类型自动为数组元素赋值。

1.byte、int、short、long类型默认为0
2.float、double默认为0.0
3.boolean默认为false、char类型默认为\u0000
4.若是引用数据类型的话，默认为null

可以在声明数组的同时进行数组内存的创建和初始化，例如：
double[] score = {98.8,85,78,100};

由于声明对象数组时，元素的默认初始化是null，因此数组初始化时需要创建对象，例如：

Student[] student = {new Student("zhangsan"),new Student("wang"),new Student("guo")};

4. 数组的使用：

数组的长度:

所有的数组都有一个属性length(长度)，他存储了数组元素的个数。

数组元素的访问：

数组元素的访问可以借助数组名和元素下标来完成。

【注意】：访问数组时要注意下标不要越界，如果下标越界，则运行时会产生“数组访问越界异常”。在实际应用中，经常使用循环来控制对数组元素的访问，访问数组的下标随循环控制变量变化。

数组的复制/拷贝：

System类中有一个静态方法：arrayCopy()方法，可以将数组中的元素的值复制给另外一个元素，而又不改变原数组的值。

public static native void arrayCopy(Object src,int srcPos,Object dest,int destPos,int length);

该方法可以将src原数组中从srcPos索引开始的连续length个元素复制到dest数组的从destPos开始的位置，且src和dest数组指向不同的内存空间。

2. 多维数组：

Java语言中，二维数组可以看为数组的数组，那么三位数组可以看为二维数组的数组。以此类推...

由于多维数组的数组元素也是数组，所以需要为数组元素分配相应的存储空间，分配空间可以在创建数组的同时进行，也可以用new运算符为数组元素分配内存。

如果多维数组中每维元素的长度不同，那么就造成数组空间的分配不是连续的。当然，一维数组的空间仍然是连续分配的。

以二维数组为例，说明二维数组的定义创建和使用等。

1. 二维数组的声明：

声明二维数组有一下两种格式：

  1. 数组元素类型 数组名[][];
  2. 数组元素类型[][] 数组名;

例如：double score[][]; double[][] score;

2. 二维数组的初始化：

二维数组可以通过new关键字初始化，或是声明的同时使用赋值语句初始化

  1. 用new初始化：

格式：数组名 = new 数组元素类型[数组的行数][数组的列数];

例如：score = new double[4][3];

表明score是一个4行3列的而数组，初始化时每个元素均为0.0，二维数组的数组元素是一维数组，因此，初始化也可各行单独进行.Java的二维数组允许每行有不同的元素个数。

  1. 用赋初值的方法初始化：

类型 数组名[][] = {{1,2,3},{4,5},{6,7,8,9}};

3. 二维数组的使用：

二维数组中使用两个下标：一个表示行、一个表示列，可以看成一个矩阵，每个下标都是从0开始。

  1. 获取二维数组的长度：

二维数组.length ------> 二维数组的行数
二维数组[i].length----> 每一行数组的个数

  1. 二维数组可以存储数据表格:

二维数组可以看成一个矩阵，同时也可以看成一个表格，利用Object的二维数组可以存储任意类型的数据。

Object[] emp1 = {1001,"gsl1",18,"讲师1","2000.09.16"};
Object[] emp2 = {1002,"gsl2",18,"讲师2","2000.09.16"};
Object[] emp3 = {1003,"gsl3",18,"讲师3","2000.09.16"};
Object[] emp4 = {1004,"gsl4",18,"讲师4","2000.09.16"};
Object[][] objects = new Object[4][];
objects[0] = emp1;
objects[1] = emp2;
objects[2] = emp3;
objects[3] = emp4;

这样就可以形成一个数据表格。

3. 二维以上的数组：

  1. 声明：多加几个括号即可。三维数组 double score[][][];以此类推...
  2. 使用：使用多个下标进行确定。

4. 数组类Arrays：

Java的工具包util中提供了工具类Arrays，该类定义了常见操作数组的静态方法，可以方便的进行数组操作，如排序和搜索等等。

Arrays提供多种基本方法：

  1. equals()用于比较两个数组是否相等。
  2. fill()用于以某个值填充整个数组。
  3. sort()用于对数组排序。
  4. binarySearch()用于在已经排序的数组中查找元素。
  5. asList()接受任意的数组为参数，并将其转变为List容器.

5. 数组的一些基本算法：

1. 数组排序-冒泡排序：

冒泡排序是最常用的排序算法。

算法重读的走访过要排序的数组，一次比较两个元素，如果他们的顺序错误，就将他们调整过来，这样越来越大的元素由于交换慢慢“浮”到数列的顶端。

算法的基本运作

  1. 比较相邻的元素，如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素都做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  3. 针对所有的而元素重复以上的步骤，除了最后一个。
  4. 针对每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

示例：冒泡排序的基础算法:

public static void main(String[] args){
	
	int[] values = {3,2,1,5,7,4,6};
	
	for(int i = 0;i<values.length - 1;i++){
        for(int j = 0, j<values.length-i-1;j++){
            if(values[j] > values[j+1]){
                int temp = values[j];
                values[j] = values[j+1];
                values[j+1] = temp;
            }
            System.out.println(Arrays.toString(values));
        }
    }
	
}

除此之外，冒泡排序可以进行优化：

根据最好情况和最差情况，当情况较好时，不需要发生多次交换，即使用flag进行条件判断，如果需要交换的时候在交换，具体代码：

public static void main(String[] args){
    int[] values = {3,2,1,5,7,4,6};
    
    //大循环表示需要循环的次数
    for(int i = 0;i<values.length-1;i++){
        //设置flag=true，若没有进入过if语句，表示子序列已经有序，不需要进行下一次循环
        boolean flag = true;
        //小循环表示需要比较的次数
        for(int j = 0;j<values.length-i-1;j++){
            if(values[j]>values[j+1]){
                int temp = values[j];
                values[j] = values[j+1];
                values[j+1] = temp;
                flag = false;
            }
            System.out.println(Arrays.toString(values));
        }
        if(flag){
            break;
        }
    }
}

2. 数组查找-二分法查找：

二分法检索(Binary search)又称作折半查找法

折半查找基本思想：

设数组的元素从小到大有序的存放在数组中

首先，将给定值key与数组中间位置(mid)上元素的关键码key比较，如果相等，则检索成功。

若key小，则在mid的前半部分数组中继续使用二分法检索；

若key大，则在mid的后半部分数组中继续使用二分法检索。

这样经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。

二分法是一种效率较高的检索方法。比如，我们要在数组[7,8,9,10,12,20,30,40,50,80,100]中查找到10元素，过程如下：

image-20200314110946568

示例：折半查找法的基础算法:

public static void main(String[] args){
    //有序数组
    int[] nums = {7,8,9,10,12,20,30,40,50,80,100};
    
    //进行折半查找
    System.out.println(binarySearch(nums, 40));
} 

private static int binarySearch(int[] values,int key){
    //设置数组的最低点和最高点
    int low = 0;
    int high = values.length-1;
    
    //循环条件：当最低点始终要比最高点低，如果高了就会重复
    while(low <= high){
        //找到数组的中间位置为mid
        int mid = (low + high) / 2;
        
        //若key大于mid的值，则继续在后面部分使用折半查找
        if(key <value[mid]){
            high = mid -1;
        }else if(key > values[mid]){
            low = mid + 1; 
        }else{
            return mid;
        }
    }
    //查询失败，返回索引为-1
    return -1;
}

标签：Java,String,int,元素,数组,字符串,public
From： https://www.cnblogs.com/guosiliang/p/18037351

相关文章

  • Java基础-面向对象概述
    本章重点针对面向对象的三大特征：继承、封装、多态进行详细的讲解。另外还包括抽象类、接口、内部类等概念。很多概念对于初学者来说，更多的是先进性语法性质的了解。1.面向对象-继承：1.继承的实现：继承通过如下格式实现：class子类名extends父类名[implements<接口名>]{}......
  • Java基础-面向过程和面向对象
    面向过程和面向对象都是对软件分析、设计和开发地一种思想，它指导着人们以不同的方式去分析、设计和开发软件。这两种思想是相辅相成的。面向过程：使用面向过程思想思考问题时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法，一步一步，最终完成。这个思想适合简单任务，不需要过多......
  • Java基础-常用类
    一、字符串相关的类1.String的特性String类：代表字符串。Java程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。String是一个final类，代表不可变的字符序列。字符串是常量，用双引号引起来表示。他们的值在创建之后不能更改。String对象的字符内容是存储在一个字符数......
  • java 实现根据word模板生成word文件 word转pdf
    最近做项目要求生成word文件及PDF文件，生成word文件时其中内容要根据不同公司提供的内容动态替换里面的值。参考了很多之后选择用word模板生成word文件。其中主要参考：https://www.cnblogs.com/suzan/p/10577738.html 简单的word模板：https://files.cnblogs.com/files/blogs/8095......
  • vue几种截取字符串的方法
    这里有几种方法可以截取数组:使用slice方法:letarr=[1,2,3,4,5];letpart=arr.slice(0,3);//从索引0开始,到索引3结束但不包含索引3,即截取前3个元素console.log(part);//[1,2,3]使用substr方法(只适用于字符串):letstr="12345";letpart=str.substr......
  • Java中使用Graphics2D实现图片添加文字/图片水印
    场景java实现给图片添加水印实现步骤：获取原图片对象信息（本地图片或网络图片）添加水印（设置水印颜色、字体、坐标等）处理输出目标图片。注：博客：https://blog.csdn.net/badao_liumang_qizhi实现1、新建工具类 importorg.apache.commons.lang3.StringUtils;importjavax.im......
  • Java 中 MessageFormat.format 用法
    转载自：https://blog.csdn.net/xiaokui_wingfly/article/details/46124057 查看原文：http://www.ibloger.net/article/139.htmlMessageFormat本身与语言环境无关，而与用户提供给MessageFormat的模式和用于已插入参数的子格式模式有关，以生成适用于不同语言环境的消息。Mes......
  • java 通过 microsoft graph 调用outlook
    废话不多说一官方文档先看一下官方文档，https://learn.microsoft.com/zh-cn/graph/tutorials/java?context=outlook%2Fcontext&tabs=aad&tutorial-step=1其中的代码，可以通过地址下载：https://developer.microsoft.com/en-us/graph/quick-start 二授权方式microsoft登录授权......
  • Java面向对象之接口和抽象类的区别一目了然
    介绍相信对于Java面向对象部分，很多人很长一段时间对于接口和抽象类的区别，使用场景都不是很熟悉，同是作为抽象层重要的对象，工作中到底什么情况下使用抽象类，不是很清楚。本文就一次性把这些概念一次性说清楚，不用再烦恼了，哈哈！核心概念接口与抽象类最明显的区别可能就是使用上的......
  • 【学习笔记】KMP算法（字符串匹配优化算法）
    KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操作（简称KMP算法）。KMP算法的作用是，在一个长字符串内匹配一个短字符串（判断str1.contains(str2)）时，减少匹配的次数，提高匹配效率。 必要概念：最长公共前后缀字符串......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99