使用Java怎么实现一个将字母的大小写相互转换功能
发布时间：2020-11-21 16:16:23
来源：亿速云
阅读：98
作者：Leah
使用Java怎么实现一个将字母的大小写相互转换功能？相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。
实现代码：
import java.util.Scanner;
/**
* 常见字母大小写转换
* 原理：
*   字符char采用的是Unicode编码的16位字符类型，其表示范围是0-65536。标准的8位ASCII字符集是Unicode
*   的子集，其取值范围为0-127。大小写字母之间正好相差32
* @author Administration
*
*/
public class WordChange {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入您需要转换的字母：");
char c = input.next().charAt(0);
change(c);
}
private static void change(char c) {
//如果输入的是大写，+32即可得到小写
if(c>='A' && c<='Z'){
c+=32;
System.out.println("您输入的大写字母"+(char)(c-32)+"被转换成了"+c);
}else if(c>='a' && c<='z'){  //如果输入的是小写，-32即可得大小写
c-=32;
System.out.println("您输入的小写字母"+(char)(c+32)+"被转换成了"+c);
}else{
System.out.println("输入的字符有误！！");
}
}
}
看完上述内容，你们掌握使用Java怎么实现一个将字母的大小写相互转换功能的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注亿速云行业资讯频道，感谢各位的阅读！

1:关键字(掌握)
(1)被Java语言赋予特定含义的单词
(2)特点：
全部小写。
(3)注意事项：
A:goto和const作为保留字存在。
B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记
2:标识符(掌握)
(1)就是给类，接口，方法，变量等起名字的字符序列
(2)组成规则：
A:英文大小写字母
B:数字
C:$和_
(3)注意事项：
A:不能以数字开头
B:不能是java中的关键字
C:区分大小写
(4)常见的命名规则(见名知意)
A:包 全部小写
单级包：小写
举例：liuyi,com
多级包：小写，并用.隔开
举例：cn.itcast,com.baidu
B:类或者接口
一个单词：首字母大写
举例：Student,Demo
多个单词：每个单词首字母大写
举例：HelloWorld,StudentName
C:方法或者变量
一个单词：首字母小写
举例：name,main
多个单词：从第二个单词开始，每个单词首字母大写
举例：studentAge,showAllNames()
D:常量
全部大写
一个单词：大写
举例：PI
多个单词：大写，并用_隔开
举例：STUDENT_MAX_AGE
3:注释(掌握)
(1)就是对程序进行解释说明的文字
(2)分类：
A:单行注释  //
B:多行注释  //
C:文档注释      / */
(3)把HelloWorld案例写了一个带注释的版本。
后面我们要写一个程序的过程。
需求：
分析：
实现：
代码体现：
(4)注释的作用
A:解释说明程序，提高了代码的阅读性。
B:可以帮助我们调试程序。
后面我们会讲解一个更高端的一个调试工具
4:常量(掌握)
(1)在程序执行的过程中，其值不发生改变的量
(2)分类：
A:字面值常量
B:自定义常量(后面讲)
(3)字面值常量
A:字符串常量 "hello"
B:整数常量  12,23
C:小数常量  12.345
D:字符常量  'a','A','0'
E:布尔常量  true,false
F:空常量   null(后面讲)
(4)在Java中针对整数常量提供了四种表现形式
A:二进制   由0，1组成。以0b开头。
B:八进制   由0，1，...7组成。以0开头。
C:十进制   由0，1，...9组成。整数默认是十进制。
D:十六进制  由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。
5:进制转换(了解)
(1)其他进制到十进制
系数：就是每一个位上的数值
基数：x进制的基数就是x
权：对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数据的权。
结果：系数*基数^权次幂之和。
(2)十进制到其他进制
除基取余，直到商为0，余数反转。
(3)进制转换的快速转换法
A:十进制和二进制间的转换
8421码。
B:二进制到八进制，十六进制的转换
6:变量(掌握)
(1)在程序的执行过程中，其值在某个范围内可以发生改变的量
(2)变量的定义格式：
A:数据类型 变量名 = 初始化值;
B:数据类型 变量名;
变量名 = 初始化值;
7:数据类型(掌握)
(1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。
(2)分类：
A:基本数据类型：4类8种
B:引用数据类型：类，接口，数组。
(3)基本数据类型
A:整数            占用字节数
byte            1
short           2
int             4
long            8
B:浮点数
float           4
double          8
C:字符
char            2
D:布尔
boolean         1
注意：
整数默认是int类型，浮点数默认是double。
长整数要加L或者l。
单精度的浮点数要加F或者f。
8:数据类型转换(掌握)
(1)boolean类型不参与转换
(2)默认转换
A:从小到大
B:byte,short,char -- int -- long -- float -- double
C:byte,short,char之间不相互转换，直接转成int类型参与运算。
(3)强制转换
A:从大到小
B:可能会有精度的损失，一般不建议这样使用。
C:格式：
目标数据类型 变量名 = (目标数据类型) (被转换的数据);
(4)思考题和面试题：
A:下面两种方式有区别吗?
float f1 = 12.345f;
float f2 = (float)12.345;
B:下面的程序有问题吗，如果有，在哪里呢?
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;
byte b4 = 3 + 4;
C:下面的操作结果是什么呢?
byte b = (byte)130;
D:字符参与运算
是查找ASCII里面的值
'a'     97
'A'     65
'0'     48
System.out.println('a');
System.out.println('a' + 1);
E:字符串参与运算
这里其实是字符串的连接
System.out.println("hello"+'a'+1);
System.out.println('a'+1+"hello");
System.out.println("5+5="+5+5);
System.out.println(5+5+"=5+5");

Java进制转换和位运算
1.常见进制的组成
2.表达形式
3.计算方法
4.任意进制转换为十进制的方法
5.十进制转换为二、八、十六进制
6.二进制中的有符号数和无符号数
7.有符号数的原码、反码和补码
8.位运算（对数字计算而言）符号

1.常见进制的组成
二进制：由0和1组成
八进制：由0,1,2,3,4,5,6,7组成
十六进制：由0到9，外加A,B,C,D,E,F六个英文字母(不分大小写)组成，A相当于十进制中的10，B是11，C是12，D是13，E是14，F是15
2.表达形式
二进制的写法：以0b开头
八进制的写法：以0开头
十六进制的写法：以0x开头
3.计算方法
规则：是几进制则满几进一，例如十进制是满十进一，二进制则是满二进一，八和十六进制同理。
例如：
		二进制：0b11110+0b111001=? 
		
					1 1 1 1 0 
			+   1 1 1 0 0 1            
			----------------------
			  1 0 0 1 0 0 0 0
			= 0b10010000
		    
		    八进制：01234+05678=？

			  	1 2 3 4
			+	5 6 7 8
			----------------------	
				7 1 3 4
			= 07134

		    十六进制：0x3ac+0x8bf6=?  

					3 a c			            	   3    10  12
			+     8 b f 6			=》同等于   	 +  8  11   15  6        =》 用十六进制表示为：0x8fa2   
			----------------------	              ----------------------
												    8  15   10  2
			=0x8fa2	   

4.任意进制转换为十进制的方法
概念说明：

系数：是指每一位上的数，例如十进制123，个位上的系数为3，十位上的系数为2，百位上的系数为1，其他进制同理；
基数：是几进制基数就是几，例如二进制的基数为2，十进制的基数为10；
权：一个数从右往左数，位置从0开始数，每一位数所在的位置就是该位的权，例如：十进制1234567，7的权是0, 6的权是1，5的权是2，4的权是3，类似于String的index；

具体方法（规律）：任意进制转换为十进制都等于“ 这个数的每一位的系数乘以基数的权次幂的和 ”。
例如：
				十进制->十进制：456 = 6*10^0 + 5*10^1 + 4*10^2 = 6+50+400 = 456
			
				二进制->十进制：0b456 = 6*2^0 + 5*2^1 + 4*2^2 = 6+10+16 = 32

				八进制->十进制：0456 = 6*8^0 + 6*8^1 + 4*8^2 = 6+48+256 = 310

				十六进制->十进制：0x456 = 6*16^0 + 5*16^1 + 4*16^2 = 6+80+1024 = 1110

5.十进制转换为二、八、十六进制
具体方法（规律）：十进制转换为任意进制，都是除以基数取余，直到商为0，然后对余数进行反转
例如：
			十进制100->二进制     
				
						2|___100__                      0    ∧
					       2 |___50____                 0    ∧
					         2 |____25_____             1    ∧
						    	2 |____12____           0    ∧    
									2|____6___          0    ∧
							  			2|____3____	    1    ∧	
							     			2|___1____	1    ∧
								  				 0
			描述：把所有余数进行组合->0010011->进行反转->1100100,也就是从下往上进行组合的顺序，所以最后表示结果为：0b1100100
			
			
			十进制100->八进制    
	
					    8|___100__	  				    4    ∧			
					       8 |___12____                 4    ∧   
					         8 |____1_____              1    ∧
									0
		    描述：把所有余数进行组合->441->进行反转->144,也就是从下往上进行组合的顺序，所以最后表示结果为：0441
			

			十进制200->十六进制     

					   16|___200__	                    8    ∧    
					     16  |___12____                 12   ∧   			       
							  	 0	
			描述：把所有余数进行组合->8c(12用字母c来代替)->进行反转->c8,也就是从下往上进行组合的顺序，所以最后表示结果为：0xc8	 

6.二进制中的有符号数和无符号数
数据有正负之分的属于有符号数，没有正反之分的属于无符号数
例如：1和-1等属于有符号数（数字有正负之分），表示正一和负一，类似文件之类的数据，视频和音频等属于无符号数，没有正负之分
有符号数由两部分（符号位+数值位）组成：

符号位：正为0，负为1，用最高位（从左往右，第一位）来表示符号位；
数值位：符号位之后的就为数值位

7.有符号数的原码、反码和补码
计算机中，有符号数是以补码的形式进行存储，以原码的形式展示出现，正数的原码、反码和补码都是一样的，负数的原

码、反码和补码是不一样的，存储和展示的时候会对其进行相互转换。
注：（平常其他进制转化为二进制时，如（除2取余），转换之后都是以原码的形式来体现的）
转换规则如下：
			原码->反码->补码
			
			原码->反码：符号位不变，其他位0变1 1变0

			反码->补码：反码加1得到补码

			反之:补码->反码->原码

			补码->反码：补码减一得到反码

			反码->原码：符号位不变，其他位0变1 1变0

例如：
		正数7的原码为：0b00000000 00000000 00000000 00000111（int类型占4个字节，1个字节是8位），

		符号位为0，正数原反补码一样，所以反码和补码也为0b00000000 00000000 00000000 00000111，

		而负数-7的原码为：0b10000000 00000000 00000000 00000111，存储时会将原码转换为补码进行存储，

		由-7原码可得：

			原码->反码：0b11111111 11111111 11111111 11111000 ,得到反码(符号位不变，其他位0变1 1变0)

			再由反码->补码：0b11111111 11111111 11111111 11111001(反码加1得到补码)
	
		所以 7在内存中存储的值0b00000000 00000000 00000000 00000111 (补码形式)

		    -7在内存中存储的值0b11111111 11111111 11111111 11111001 (补码形式)

8.位运算（对数字计算而言）符号

&：按位与
| ：按位或
^：按位异或
~：按位取反
<<：左移
>>：右移
>>>：无符号右移

在进行位运算的时候，需要先把数据先转换成二进制位，并且都是以二进制的补码形式进行操作
例如：
			4的二进制为：0b00000000 00000000 00000000 00000100(正数原反补码都一样，在此表示为补码形式)

			6的二进制为：0b00000000 00000000 00000000 00000110(正数原反补码都一样，在此表示为补码形式)

			(1)按位与规则：两个同时为1，则为1，否则为0

				4 & 6 = 0b00000000 00000000 00000000 00000100(补码形式) = 0*2^0+0*2^1+1*2^2 =  4(在此表示为原码形式)

			(2)按位或规则：一个为1，则为1，否则为0

				4 | 6 = 0b00000000 00000000 00000000 00000110(补码形式) = 0*2^0+1*2^1+1*2^2 = 6(在此表示为原码形式)

			(3)按位异或规则：两个不一样的时候为1，否则为0

				4 ^ 6 = 0b00000000 00000000 00000000 00000010(补码形式) = 0*2^0+1*2^1 = 2(在此表示为原码形式)

			(4)按位取反规则：0变1，1变0

				~4 = 0b11111111 11111111 11111111 11111011(补码形式)，可以看出最高位1，所以结果为负数，

				需要把结果由补码转为反码，然后反码转为原码即可得出最后结果，因此：

					（1）0b11111111 11111111 11111111 11111011(补码形式)
						
			  		（2）转为反码：0b11111111 11111111 11111111 11111010(反码形式)

					（3）由反码转为原码：0b10000000 00000000 00000000 000000101(原码形式) = -(1*2^0+0*2^1+1*2^2)=-(1+4)=-5

				~6同理，结果为：~6 = 0b11111111 11111111 11111111 11111001(补码形式)

					-> 转反码： = 0b11111111 11111111 11111111 11111000(反码形式)
					
					-> 转原码： = 0b10000000 00000000 00000000 00000111(原码形式) = -（1*2^0+1*2^1+1*2^2）=-(1+2+4)=-7

			(5)按位左移规则：操作数乘以2的n次幂，n为左移的位数

				具体操作方式：左移几位，就将二进制位向左移动几位，舍弃移除的位数，然后右边空出的位用0填补

				例如4的二进制为：0b00000000 00000000 00000000 00000100(正数原反补码都一样，在此表示为补码形式)

				4 << 6 

				->将4的二进制的补码左移6位-> 0b00000000 00000000 00000001 00->右边空出的位补0

				-> 0b00000000 00000000 00000001 00000000->判断符号位是0还是1

				->符号位（最高位）为0是正数，所以不用进行码转换操作(正数原反补码都一样,在此表示为原码形式)

				->  = 0*2^0+0*2^1+0*2^2+0*2^3+0*2^4+0*2^5+0*2^6+0*2^7+1*2^8 = 2^8= 256(也就是4乘以2的6次方)

			(6)按位右移规则：操作数(正数)除以2的n次幂，n为右移的位数

				具体操作方式：右移几位，就将二进制位向右移动几位，舍弃移除的位数，然后左边空出的位由符号位来决定，

					      符号位为0，则用0填补，符号位为1，则用1填补
				
				例如4的二进制为：0b00000000 00000000 00000000 00000100(正数原反补码都一样，在此表示为补码形式)

				4 >> 6 

				->将4的二进制的补码右移6位-> 0b00000000 00000000 00000000 00

				->判断符号位是0还是1

				->符号位（最高位）为0（右移 符号位为0，则用0填补，符号位为1，则用1填补）

				->0b00000000 00000000 00000000 00000000->最高位为0是正数，所以不用进行码转换操作(正数原反补码都一样,在此表示为原码形式)->

				->  = 0 (也就是4除以2的6次方)
			
			对负数进行左移或者右移操作方式如下：

				规则：因为位移操作都是以二进制的补码形式进行操作的，所以首先需要得到负数的原码之后，再求的补码，才能对其进行位操作。
		
				例如-4的二进制为：0b10000000 00000000 00000000 00000100(在此表示为原码形式)

						  原码->反码：0b11111111 11111111 11111111 11111011

						  反码->补码：0b11111111 11111111 11111111 11111100	
		
				求得-4的二进制补码形式为：0b11111111 11111111 11111111 11111100

				(1)-4 << 6 

				   ->将-4的二进制的补码左移6位

				   ->0b11 11111111 11111111 11111100->判断符号位是0还是1->符号位（最高位）为1

				   ->0b11111111 11111111 11111111 00000000(补码形式)->最高位为1是负数，所以需要转换成反码的形式
				
				   ->0b11111111 11111111 11111110 11111111(反码形式)

				   ->0b10000000 00000000 00000001 00000000(原码形式)

				   -> = -(0*2^0+0*2^1+0*2^2+0*2^3+0*2^4+0*2^5+0*2^6+0*2^7+1*2^8) = -1*2^8 = -256 (也就是-4乘以2的6次方)
				
				(2)-4 >> 6 

				   ->将-4的二进制的补码右移6位-> 0b11111111 11111111 11111111 11->判断符号位是0还是1->符号位（最高位）为1

				   ->（右移 符号位为0，则用0填补，符号位为1，则用1填补）

				   ->0b11111111 11111111 11111111 11111111(补码形式)->最高位为1是负数，所以需要转换成反码的形式
				
				   ->0b11111111 11111111 11111111 11111110(反码形式)

				   ->0b10000000 00000000 00000000 00000001(原码形式)

				   -> = -(1*2^0) = -1

					
			(7)按位无符号右移：
		
				具体操作方式与右移规则一样，与右移操作符的区别在于，右移的空位有符号位来决定,符号位为0，则用0填补，符号位为1，则用1填补，而无符号右移，

				左边空出的位则全都由0来填补,不由符号位决定
					           
				例如-4 >>> 6 

				   ->将-4的二进制位右移6位-> 0b11111111 11111111 11111111 11

				   ->（空位由0来填补）

				   -> 0b00000011 11111111 11111111 11111111(补码形式)

				   ->最高位为0是正数，所以不用进行码转换操作(正数原反补码都一样,在此表示为原码形式)

				   -> = 1*2^0+1*2^1+1*2^2+1*2^3+1*2^4+1*2^5+1*2^6+...+1*2^25 = 67108863

由此可见，对于正数来说，右移和无符号右移是没区别的,对于负数有些是不能用算术右移来实现除法（例如-32 >> 2 就符合除法规则结果为-8）
以上是最近学习位运算的一些总结，如上述代码有错误之处，还请指出，再次感谢！！

Java字符串创建与初始化实例。Java字符串String方法总结，包括字符串的大小写替转换，获取字符串长度的方法、截取字符串，去除字符串中的空格、StringBuffer类转换成String类等：
java创建并初始化字符串的方法：
1、使用字符串常量直接初始化 String s=”hello!”;
2、使用构造方法创建并初始化 String();//初始化一个对象，表示空字符序列
String(value);//利用已存在的字符串常量创建一个新的对象
String (char[] value);//利用一个字符数组创建一个字符串
String(char[] value,int offset,int count);//截取字符数组offset到count的字符创建一个非空串
String(StringBuffer buffer);//利用StringBuffer对象初始化String对象
java String类主要方法的使用实例介绍：
1、获取长度方法 *.length();//这与数组中的获取长度不同，*.length;
2、比较字符串(1) equals() //判断内容是否相同
(2)compareTo() //判断字符串的大小关系
(3)compareToIgnoreCase(String int) //在比较时忽略字母大小写
(4)== //判断内容与地址是否相同
(5)equalsIgnoreCase() //忽略大小写的情况下判断内容是否相同
如果想对字符串中的部分内容是否相同进行比较，可以用
(6)reagionMatches() //有两种 public boolean regionMatches(int toffset, String other,int ooffset,int len);表示如果String对象的一个子字符串与参数other的一个子字符串是相同的字符序列，则为true.要比较的String 对象的字符串从索引toffset开始,other的字符串从索引ooffset开始，长度为len。
public boolean reagionMatches(boolean ignoreCase,int toffset,String other,int ooffset,int len);//用布尔类型的参数指明两个字符串的比较是否对大小写敏感。
java如何查找字符串中某个位置的字符
public char charAt(int index);//返回指定索引index位置上的字符，索引范围从0开始
查找指定字符串在字符串中第一次或最后一词出现的位置
在String类中提供了两种查找指定位置的字符串第一次出现的位置的方法
(1)public int indexOf(String str);//从字符串开始检索str，并返回第一次出现的位置，未出现返回-1
(2)public int indexOf(String str,int fromIndex);//从字符串的第fromIndex个字符开始检索str
查找最后一次出现的位置有两种方法
(1)public int lastIndexOf(String str);
(2)public int lastIndexOf(String str,int fromIndex);
如果不关心字符串的确切位置则可使用public boolean contains(CharSequence s);
检查字符串的起始字符和结束字符
开始的字符串两种方法
(1)public boolean starWith(String prefix,int toffset);//如果参数prefix表示的字符串序列是该对象从索引toffset处开始的子字符串，则返回true
(2)public boolean starWith(String prefix);
结束的字符串方法
public boolean endsWith(String suffix);
java截取子串方法
(1)public String subString(int beginIndex);
(2)public String subString(int beginIndex,int endIndex);//返回的字符串是从beginIndex开始到endIndex-1的串
要返回后4位可以这样写Syetem.out.println(*.subString()(*.length()-4));
java字符串的替换的方法
(1)public String replace(char oldChar,char newChar);
(2)public String replace(CharSequence target,CharSequence replacement);//把原来的etarget子序列替换为replacement序列，返回新串
(3)public String replaceAll(String regex,String replacement);//用正则表达式实现对字符串的匹配
字符串的大小写替转换
(1)public String toLowerCase(Locale locale);
(2)public String toLowerCase();
(3)public String toupperCase(Locale locale);
(4)public String toUpperCase();
去除字符串首尾空格
*.trim();
字符串转换
1、将字符串转换成字符数组
public char[] toCharArray();
2、将字符串转换成字符串数组
public String[] split(String regex);//regex 是给定的匹配
3、将其它数据类型转化为字符串
(1)public static String valueOf(boolean b);
(2)public static String valueOf(char c);
(3)public static String valueOf(int i);
(4)public static String valueOf(long i);
(5)public static String valueOf(float f);
(6)public static String valueOf(double d);
(7)public static String valueOf(char[] data);
(8)public static String valueOf(Object obj);
可变字符串的创建和初始化
两种方法:
public StringBuffer();
public StringBuffer(int caoacity);
StringBuffer类主要方法的使用：
一、获取可变字符串长度
(1)public int length();
(2)public int capacity();
(3)public void setLength(int newLength);
二、比较可变字符串
用String 类的equals()方法比较，但是不同。
类Object中的equals()方法比较的是两个对象的地址是否相等，而不仅仅是比较内容，但是String类在继承Object类的时候重写了equals()方法，只是比较两个对象的内容是否相等
而在StringBuffer类中没有重写Object类的equals()方法，所以比较的是地址和内容。
三、追加和插入字符串
(1)追加 public StringBuffer append(type t);
(2)插入 public StringBuffer insert(int offset,type t);//在offset处加入类型为type的字符串
四、反转和删除字符串
(1)反转 public StringBuffer reverse();
(2)删除 public StringBuffer delete(int start,int end);
五、减少用于可变字符序列的存储空间
public void trimToSize();
六、StringBuffer类转换成String类
public String toString();