java笔记
作者：互联网
JAVA入门学习
数据类型转化
如果直接将byte类型的数据与int类型的数据相加，会报错，所以需要加强制类型转换符，代码格式如下：
int aa=10;
byte bb=5;
byte dd=(byte)(aa+bb);
System.out.println(dd);
强制类型转换也不是随随便便就可以使用的，也可能造成数据精度丢失的问题。
隐式类型转换（由小转到大）
数据类型的范围由小到大：
byte，short，char–>int–>long–>double
强制类型转换（由大到小）
目标类型 变量名 = （目标类型）要转换的值
注意精度丢失
字符+整形
int a=10;
char c='a';
System.out.println(a+c);//结果为107
字符参与加法运算时，其实是拿该字符在计算机中的数据值来计算的
运算符
a++ a=a+a
a-- a=a-a
创建整形数组
int[] arry={1,2,3,4,5};
创建字符串
String str="hjgcvyh";//字符串
String [] skr={"j","k","f","v","s"};//字符数组
求字符串长度
String str="hjkgfvcktgh";
int sum=str.length();
如何判断两个字符串元素组成相同
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:
输入: s = “rat”, t = “car”
输出: false
说明:
你可以假设字符串只包含小写字母。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-anagram
public boolean isAnagram(String s, String t) {
int sl=s.length();
int tl=t.length();
boolean len=false;
if(sl==tl)
{
char[] str=s.toCharArray();//将字符串转换为字符数组
char[] ttr=t.toCharArray();
Arrays.sort(str);//对字符数组进行排序
Arrays.sort(ttr);
return Arrays.equals(str,ttr);//判断两个字符数组是否相同
}
return false;
}
数组排序
牛牛在各个平台被各种传奇游戏的广告轰炸，所以他决定去玩一玩这类的游戏。这类游戏挂机就可以升级，所以牛牛每天都能变强。在第i天里，牛牛能杀死防御力小于等于i的怪物。但由于牛牛还要刷题，所以牛牛每天最多杀一只怪物。这个游戏共有n只怪物，每只怪物的防御力为DEF[i]，牛牛想知道最少要到第几天才能把这n只怪物都杀死。
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
* @param n int整型
* @param DEF int整型一维数组
* @return int整型
*/
public int Minimumdays (int n, int[] DEF) {
// write code here
Arrays.sort(DEF,0,n);
int data=0;
for(int i=0;i<n;i++)
{
if(data<DEF[i])
{
data=DEF[i];
}
else{
data++;
}
}
return data;
}
}
四数相加
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。
例如:
输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:
2
解释:
两个元组如下:
- (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
- (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/4sum-ii
哈希表解决
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class jihuo {
public static void main(String[] args) {
int[] A={1,2};
int[] B={-2,-1};
int[] C={-1,2};
int[] D={0,2};
Map<Integer,Integer> contAB=new HashMap<Integer,Integer>();
for (int u:A)
{
for (int v:B)
{
contAB.put(u+v,contAB.getOrDefault(u+v,0)+1);
}
}
int ans=0;
for (int u:C)
{
for (int v:D)
{
if(contAB.containsKey(-u-v))
{
ans+=contAB.get(-v-u);
}
}
}
System.out.println(ans);
}
}
快速幂
//求a的b次方
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class jihuo {
public static void main(String[] args) {
int a=5;
int b=3;
int sesout=1;
while (b>0)
{
if(b%2==1)
{
sesout=(sesout*a)%10000;
}
b=b/2;
a=(a*a)%10000;
}
System.out.println(sesout);
}
}
将字符串转换为ASCLL码
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class HolleWord {
public static void main(String[] args) {
String s="gfjtfrakwsjydfghkgckhg";
int t=s.length();
char[] str=s.toCharArray();
Arrays.sort(str);
int[] arry=new int[500];
for (int i=0;i<t;i++)
{
arry[i]=Integer.valueOf(str[i]);
System.out.println(str[i]+"的ASCII码为"+arry[i]);
}
}
}
/*输出
a的ASCII码为97
c的ASCII码为99
d的ASCII码为100
f的ASCII码为102
f的ASCII码为102
f的ASCII码为102
g的ASCII码为103
g的ASCII码为103
g的ASCII码为103
g的ASCII码为103
h的ASCII码为104
h的ASCII码为104
j的ASCII码为106
j的ASCII码为106
k的ASCII码为107
k的ASCII码为107
k的ASCII码为107
r的ASCII码为114
s的ASCII码为115
t的ASCII码为116
w的ASCII码为119
y的ASCII码为121*/
何时调用构造函数
层次结构创建以后，组成层次结构的类的构造函数以怎样的顺序被调用？举个例子来说，给定一个名为B的子类和超类A，是A的构造函数在B的构造函数之前调用，还是情况相反？回答是在类层次结构中，构造函数以派生的次序调用，从超类到子类。而且，尽管super( )必须是子类构造函数的第一个执行语句，无论你用到了super( )没有，这个次序不变。如果super( )没有被用到，每个超类的默认的或无参数的构造函数将执行。下面的例子阐述了何时执行构造函数：
class A{
double a;
double b;
A()
{
System.out.println("调用了A的构造函数");
}
}
class B extends A{
B()
{
System.out.println("调用了B的构造函数");
}
}
class C extends B{
C()
{
System.out.println("调用了C的构造函数");
}
}
public class text1 {
public static void main(String[] args) {
C c=new C();
}
}
//输出样例
//调用了A的构造函数
//调用了B的构造函数
//调用了C的构造函数
如你所见，构造函数以派生的顺序被调用。
仔细考虑，构造函数以派生的顺序执行是很有意义的？
因为超类不知道任何子类的信息，任何它需要完成的初始化是与子类的初始化分离的，而且它可能是完成子类初始化的先决条件。因此，它必须最先执行。
方法重载
当建立应该层次结构以后，如果子类中的方法与超类中的方法名相同和定义的类型相同，那么这个子类中的方法重载超类中的方法。这时超类中的方法会被隐藏。如下所示：
class A{
double a;
double b;
A(double x,double y)
{
a=x;
b=y;
}
double area(){
return 0;
}
}
class B extends A{
B(double x,double y)
{
super(x,y);
}
double area()
{
return a*b;
}
}
class C extends B{
C(double x,double y)
{
super(x,y);
}
double area()
{
return (a+b)/2;
}
}
public class text1 {
public static void main(String[] args) {
A a=new A(12,5);
B b=new B(20,6);
C c=new C(5,7);
A f;
f=a;
System.out.println(f.area());
f=b;
System.out.println(f.area());
f=c;
System.out.println(f.area());
}
}
//0.0
//120.0
//6.0
以下代码运行的结果是：
public class Demo { class Super{ int flag=1;
Super(){
test();
} void test(){
System.out.println("Super.test() flag="+flag);
}
} class Sub extends Super{
Sub(int i){ flag=i;
System.out.println("Sub.Sub()flag="+flag);
} void test(){
System.out.println("Sub.test()flag="+flag);
}
} public static void main(String[] args) { new Demo().new Sub(5);
}
}
答案
Sub.test()flag=1
Sub.Sub()flag=5
解释：在只想new Sub(5)的时候，父类先初始化了 int flag = 1，然后执行父类的构造函数Super（），父类构造函数中执行的test（）方法，因子类是重写了test（）方法的，因此父类构造函数中的test（）方法实际执行的是子类的test（）方法，所以输出为Sub.test() flag=1，接着执行子类构造函数Sub(5) 将flag赋值为5，因此输出结果Sub.Sub() flag=5。
标签：java,int,笔记,class,码为,ASCII,public,构造函数 来源： https://blog.csdn.net/weixin_44644871/article/details/109524458