StudyTonight Java 中文教程（二）
原文：StudyTonight
Java Float类
Float 类将基元类型的浮点值包装在对象中。Float类型的对象包含一个类型为浮点的字段。
此外，此类提供了几种将浮点转换为字符串和将字符串转换为浮点的方法，以及处理浮点时有用的其他常量和方法。
声明:
public final class Float extends Number implements Comparable<Float>
下面是 Float 类的方法及其示例。
1.toString()
它返回一个表示指定浮点对象的新字符串。下面给出了该方法的语法。
语法:
public String toString(float b)
示例:
让我们举一个例子来获取Float类型的字符串对象。我们使用了toString()方法，它是静态的，所以我们可以用类名来调用它。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
System.out.println("toString(a) = " + Float.toString(a));
}
}
2.valueOf()
此方法返回一个表示指定浮点值的浮点实例。该方法通常应该优先于构造器 Float(float)使用。
句法
public static Float valueOf(float b)
示例:
在这个例子中，我们使用了 valueOf()方法，该方法返回代表指定Float类型的Float类的实例。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
String b = "63";
Float x = Float.valueOf(a);
System.out.println("valueOf(a) = " + x);
x = Float.valueOf(b);
System.out.println("ValueOf(b) = " + x);
}
}
3.解析浮点()
此方法返回指定字符串值的浮点值。我们可以用它从String类型值中获取一个浮点值。
语法:
public static float parseFloat(String val) throws NumberFormatException
示例:
让我们举一个例子，其中我们有一个String类型的变量，并使用parseFloat()方法获取其浮点值。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
String b = "63";
float x = Float.parseFloat(b);
System.out.println("parseFloat(b) = " + x);
}
}
4. 字节值（）
此方法用于从浮点对象中获取一个基元类型的浮点值。它在转换为类型 float 后返回由该对象表示的数值。
句法
public byte byteValue()
5. 短值（）
此方法在扩展基元转换后以短整型形式返回此 Float 的值。
句法
public short shortValue()
6. intValue（）
intValue()方法在一个扩展原始类型转换后，将该浮点值作为一个原始类型 int 类型返回。下面给出了该方法的语法。
句法
public int intValue()
7. 长值（）
longValue()方法在扩展原始类型转换后，将该Float类型的值作为Long类型返回。下面给出了该方法的语法。
句法
public long longValue()
8.doubleValue()
它在扩展基元转换后，将此Float类型的值作为双精度类型返回。下面给出了该方法的语法。
句法
public double doubleValue()
9. 浮点值（）
此方法用于在扩展基元转换后将此Float类型的值作为Float类型获取。下面给出了该方法的语法。
语法:
public float floatValue()
示例:
让我们举一个例子来转换Float类型为 int，long 和 float 类型的值。在这个例子中，我们使用intValue(), floatValue(), doubleValue()方法。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
Float obj = new Float(a);
System.out.println("bytevalue(obj) = " + obj.byteValue());
System.out.println("shortvalue(obj) = " + obj.shortValue());
System.out.println("intvalue(obj) = " + obj.intValue());
System.out.println("longvalue(obj) = " + obj.longValue());
System.out.println("doublevalue(obj) = " + obj.doubleValue());
System.out.println("floatvalue(obj) = " + obj.floatValue());
}
}
10. hashCode()
此方法用于获取浮点值的哈希代码。它返回一个浮点对象的 int 值。
语法:
public inthashCode()
示例:
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
Float obj = new Float(a);
int x = obj.hashCode();
System.out.println("hashcode(x) = " + x);
}
}
11. isNaN（）
此方法返回真或假的布尔值。如果这个浮点值是一个非数字(NaN) ，则返回真，否则返回假。
语法:
public booleanisNaN()
示例:
让我们举个例子来检查给定的浮点值是否是 NaN。见下面的例子。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
Float obj = new Float(a);
Float x = Float.valueOf(a);
System.out.println("isNaN(d) = " + x.isNaN());
}
}
12. 是无限（）
此方法用于检查浮点值的大小是否无限大。它返回真或假的布尔值。下面给出了该方法的语法。
语法:
public booleanisInfinite()
示例:
我们可以用这个方法来检查浮点值的范围是否无限。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
Float obj = new Float(a);
Float x = Float.valueOf(a);
x = Float.valueOf(Float.POSITIVE_INFINITY + 1);
System.out.println("Float.isInfinite(x) = " + Float.isInfinite(x.floatValue()));
}
}
13. 十六进制字符串（）
此方法用于获取浮点参数的十六进制字符串表示形式。它接受一个浮点型参数，该参数将被转换为十六进制值。下面给出了该方法的语法。
语法:
public static String toHexString(float val)
示例:
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
Float obj = new Float(a);
System.out.println("Float.toString(a) = " + Float.toHexString(a));
}
}
14.浮点位()
此方法用于根据 IEEE 754 浮点“单一格式”位布局获取指定浮点值的表示。它需要浮点参数。下面给出了该方法的语法。
语法:
public static intfloatToIntBits(float val)
示例:
在这个例子中，我们使用floattointbits()方法返回浮点值的位布局。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
Float obj = new Float(a);
int x = Float.floatToIntBits(a);
System.out.println("Float.floatToLongBits(a) = " + x);
}
}
15.floatToRawIntBits()
此方法根据 IEEE 754 浮点“单一格式”位布局返回指定浮点值的表示形式，保留非数字(NaN)值。下面给出了该方法的语法。
语法:
public static intfloatToRawIntBits(float val)
示例:
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 72.05F;
Float obj = new Float(a);
int x = Float.floatToRawIntBits(a);
System.out.println("Float.floatToRawIntBits(a) = " + x);
}
}
16.IntBitsToFloat()
此方法用于获取具有相同位模式的浮点值。根据 IEEE 754 浮点“单一格式”位布局，该参数被认为是浮点值的表示。下面给出了该方法的语法。
语法:
public static float IntBitsToFloat(long b)
示例:
让我们举个例子来理解一下返回浮点值的intbitstofloat()方法。
public class FloatDemo1
{
public static void main(String[] args)
{
int a = 72;
float y = Float.intBitsToFloat(a);
System.out.println("Float.intBitsToFloat(a) = " + y);
}
}
17.等于()
equals()方法将一个对象与指定的对象进行比较。如果对象相同，则返回 true 否则为假。下面给出了该方法的语法。
语法:
public boolean equals(Object obj)
示例:
我们正在使用 equals 方法比较两个浮点对象，如果两个对象都为真，则该方法返回 true。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 25.34F;
String b = "26";
Float obj = new Float(a);
Float obj1 = new Float(b);
boolean x = obj.equals(obj1);
System.out.println("obj.equals(obj1) = " + x);
}
}
18.compareTo()
此方法用于对两个浮动对象进行数值比较。如果两个浮点对象相等，则返回 0。如果一个浮点对象小于参数对象，则返回小于 0 的值。如果一个浮点对象的数值大于参数浮点对象，则返回大于 0 的值。下面给出了该方法的语法。
语法:
public intcompareTo(Float b)
示例:
在本例中，我们使用compareTo()方法比较两个浮动对象，该方法对两个浮动对象进行数值比较并返回一个数值。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 25.34F;
String b = "26";
Float obj = new Float(a);
Float obj1 = new Float(b);
int x = obj.compareTo(obj1);
System.out.println("obj.compareTo(obj1) = " + x);
}
}
19.比较()
它用于在数值上比较两个浮点值。返回的值与。下面给出了该方法的语法。
语法:
public static int compare(float x,float y)
示例:
我们可以使用比较方法来比较两个浮点值。如果两者相等，则返回 0，否则返回负值或正值。
public class FloatDemo1
{
public static void main(String[] args)
{
float a = 25.34F;
String b = "26";
Float obj = new Float(a);
Float obj1 = new Float(b);
int x = Float.compare(obj, obj1);
System.out.println("compare(obj, obj1) = " + x);
}
}
Java Double类
double 类是一个包装类，用于包装对象中基本 Double 类型的值。类型为 double 的对象包含类型为 Double 的单个字段。Double 类扩展了 Number 类并实现了 Comparable 接口。
此外，此类提供了将双精度转换为字符串和将字符串转换为双精度的几种方法，以及处理双精度时有用的其他常量和方法。该类的声明如下。
声明:
public final class Double extends Number implements Comparable<Double>
在这里，我们将解释 Double 类的方法和它们的例子。
1.toString()
它返回一个表示指定双精度对象的新字符串。下面给出了该方法的语法。
语法:
public String toString(double b)
示例:
让我们举一个例子来获取一个双重类型的字符串对象。我们使用了静态的 toString()方法，这样我们就可以通过使用类名来调用它。见下面的例子。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
System.out.println("toString(a) = " + Double.toString(a));
}
}
2.valueOf()
此方法返回一个表示指定双精度值的 Double 实例。此方法通常应优先于构造器 Double(double)使用。它需要Double类型的单个参数。
语法:
public static Double valueOf(double b)
示例:
在这个例子中，我们使用valueOf()方法返回表示指定双精度类型的 Double 类的实例。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
String b = "85";
Double x = Double.valueOf(a);
System.out.println("valueOf(a) = " + x);
x = Double.valueOf(b);
System.out.println("ValueOf(b) = " + x);
}
}
3.parseDouble()
此方法返回指定字符串值的双精度值。我们可以用它从String类型值中获取一个双精度值。它只接受一个String类型的参数。
语法:
public static double parseDouble(String val) throws NumberFormatException
示例:
让我们举一个例子，其中我们有一个String类型的变量，并使用parseDouble()方法获得它的双精度值。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
String b = "85";
double x = Double.parseDouble(b);
System.out.println("parseDouble(b) = " + x);
}
}
4. 字节值（）
该方法用于从 double 对象中获取一个基元类型的 Double 值。在转换为 double 类型后，它返回由该对象表示的数值。
句法
public byte byteValue()
5. 短值（）
此方法在加宽基元转换后，将此 double 的值作为 Double 返回。下面给出了该方法的语法。
句法
public short shortValue()
6. intValue（）
intValue()方法在扩展基元转换后，将该 Double 的值作为基元 int 类型返回。下面给出了该方法的语法。
句法
public int intValue()
7. 长值（）
longValue()方法在扩展原始类型转换后，将该 Double 类型的值作为Long类型返回。下面给出了该方法的语法。
句法
public long longValue()
8.doubleValue()
它在扩展基元转换后，将该 double 类型的值作为 Double 类型返回。下面给出了该方法的语法。
句法
public double doubleValue()
9. 浮点值（）
此方法用于在扩展基元转换后将此 Double 类型的值作为Float类型获取。下面给出了该方法的语法。
句法
public float floatValue()
示例:
让我们举一个例子，将 double 类型转换为 int、long 和 float 类型的值。在这个例子中，我们使用intValue(), floatValue(), doubleValue()方法。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
Double obj = new Double(a);
System.out.println("bytevalue(obj) = " + obj.byteValue());
System.out.println("shortvalue(obj) = " + obj.shortValue());
System.out.println("intvalue(obj) = " + obj.intValue());
System.out.println("longvalue(obj) = " + obj.longValue());
System.out.println("doublevalue(obj) = " + obj.doubleValue());
System.out.println("floatvalue(obj) = " + obj.floatValue());
}
}
10. hashCode()
此方法用于获取Double类型值的哈希代码。它返回一个双对象的 int 值。
语法:
public inthashCode()
示例:
public static void main(String[] args)
{
double a = 46.23;
Double obj = new Double(a);
int x = obj.hashCode();
System.out.println("hashcode(x) = " + x);
}
}
11. isNaN（）
此方法返回真或假的布尔值。如果这个 Double 值是一个非数字(NaN) ，则返回 true，否则返回 false。
语法:
public booleanisNaN()
示例:
让我们举个例子来检查给定的双精度值是否是 NaN。见下面的例子。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
Double obj = new Double(a);
Double x = Double.valueOf(a);
System.out.println("isNaN(x) = " + x.isNaN());
}
}
12. 是无限（）
这个方法是用来检查双值的大小是否无限大。它返回真或假的布尔值。下面给出了该方法的语法。
语法:
public booleanisInfinite()
示例:
我们可以用这个方法来检查 Double 值的范围是否无限。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
Double obj = new Double(a);
Double x = Double.valueOf(a);
x = Double.valueOf(Double.POSITIVE_INFINITY + 1);
System.out.println("Double.isInfinite(x) = " + Double.isInfinite(x.doubleValue()));
}
}
13. 十六进制字符串（）
此方法用于获取双参数的十六进制字符串表示形式。它采用Double类型参数，该参数将被转换为十六进制值。下面给出了该方法的语法。
语法:
public static String toHexString(double val)
示例:
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
Double obj = new Double(a);
Double x = Double.valueOf(a);
System.out.println("Double.toHexString(a) = " + Double.toHexString(a));
}
}
14.doubleToLongBits()
此方法用于根据 IEEE 754 浮点“单一格式”位布局获取指定浮点值的表示。它需要浮点参数。下面给出了该方法的语法。
语法:
public static long doubleToLongBits(double val)
示例:
在本例中，我们使用 floattointbits()方法，该方法返回浮点值的位布局。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
Double obj = new Double(a);
long x = Double.doubleToLongBits(a);
System.out.println("Double.doubleToLongBits(a) = " + x);
}
}
15.doubleToRawLongBits()
此方法根据 IEEE 754 浮点“单一格式”位布局返回指定浮点值的表示形式，保留非数字(NaN)值。下面给出了该方法的语法。
语法:
public static long doubleToRawLongBits(double val)
示例:
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
Double obj = new Double(a);
long x = Double.doubleToRawLongBits(a);
System.out.println("Double.doubleToRawLongBits(a) = " + x);
}
}
16.LongBitsToDouble()
此方法用于获取具有相同位模式的双浮点值。根据 IEEE 754 浮点“单一格式”位布局，该参数被认为是浮点值的表示。下面给出了该方法的语法。
句法
public static double LongBitsToDouble(long b)
示例:
让我们举一个例子来理解返回浮点值的 intbitstofloat()方法。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
Double obj = new Double(a);
long x = Double.doubleToLongBits(a);
double y = Double.longBitsToDouble(x);
System.out.println("Double.LongBitsToDouble(x) = " + y);
}
}
17.等于()
equals()方法将一个对象与指定的对象进行比较。如果对象相同，则返回 true 否则为假。下面给出了该方法的语法。
语法:
public boolean equals(Object obj)
示例:
我们正在使用 equals 方法比较两个双对象，如果两个对象都为真，则该方法返回 true。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
String b ="12";
Double obj = new Double(a);
Double obj1 = new Double(b);
boolean x = obj.equals(obj1);
System.out.println("obj.equals(obj1) = " + x);
}
}
18.compareTo()
这种方法用于对两个双物体进行数值比较。如果两个双对象相等，则返回 0。如果一个双精度对象小于参数对象，则返回小于 0 的值。如果一个 double 对象的数值大于参数 double 对象，则返回大于 0 的值。下面给出了该方法的语法。
语法:
public intcompareTo(Double b)
示例:
在本例中，我们使用compareTo()方法比较两个双对象，该方法对两个双对象进行数值比较并返回一个数值。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
String b ="12";
Double obj = new Double(a);
Double obj1 = new Double(b);
int x = obj.compareTo(obj1);
System.out.println("obj.compareTo(obj1) = " + x);
}
}
19.比较()
它用于在数值上比较两个双精度值。返回的值与。下面给出了该方法的语法。
语法:
public static int compare(double x,double y)
示例:
我们可以使用比较方法来比较两个双精度值。如果两者相等，则返回 0，否则返回负值或正值。
public class DoubleDemo1
{
public static void main(String[] args)
{
double a = 46.23;
String b ="12";
Double obj = new Double(a);
Double obj1 = new Double(b);
int x = Double.compare(obj, obj1);
System.out.println("compare(obj, obj1) = " + x);
}
}
Java Boolean类
Boolean类是类中的包装器，用于包装对象中基本类型布尔的值。Boolean类型的对象包含一个类型为布尔的字段。
这个类包含许多帮助方法，用于将布尔值转换为字符串和将字符串转换为布尔值，以及在使用布尔值时有帮助的其他常量和方法。
这个类位于 java.lang 包中，有以下声明。
申报
public final class Boolean extends Object implements Serializable, Comparable<Boolean>
这里我们解释Boolean类的各种方法和它们的例子。
1.解析布尔(字符串)
parseBoolean()方法用于将字符串参数解析为布尔值。它返回真或假的布尔值。如果字符串参数不为 null 并且等于字符串“true”，则忽略大小写，返回 true。
它接受一个包含要解析的布尔表示的字符串参数。
语法:
public static boolean parseBoolean(String s)
示例:
在本例中，我们使用parseBoolean()方法将字符串参数解析为Boolean类型。如果指定的字符串可以解析为布尔值，则此方法返回 true，否则返回 false。
public class booleanDemo1
{
public static void main(String[] args)
{
boolean obj1 = Boolean.parseBoolean("True");
boolean obj2 = Boolean.parseBoolean("False");
boolean obj3 = Boolean.parseBoolean("StUdYtONiGhT");
boolean obj4 = Boolean.parseBoolean("STUDYTONIGHT");
boolean obj5 = Boolean.parseBoolean("studytonight");
System.out.println(obj1);
System.out.println(obj2);
System.out.println(obj3);
System.out.println(obj4);
System.out.println(obj5);
}
}
2.booleanValue()
booleanValue()方法用于获取该布尔对象的布尔值作为布尔基元。它返回布尔对象的基元类型布尔值。该方法的声明如下。
语法:
public boolean booleanValue()
示例:
我们使用booleanValue()方法获取布尔对象的布尔值。见下面的例子。
public class booleanDemo1
{
public static void main(String[] args)
{
Boolean obj1 = new Boolean("True");
Boolean obj2 = new Boolean("StUdYtONiGhT");
Boolean obj3 = new Boolean("STUDYTONIGHT");
Boolean obj4 = new Boolean("studytonight");
boolean obj5 = obj1.booleanValue();
boolean obj6 = obj2.booleanValue();
boolean obj7 = obj3.booleanValue();
boolean obj8 = obj4.booleanValue();
System.out.println(obj5);
System.out.println(obj6);
System.out.println(obj7);
System.out.println(obj8);
}
}
3.valueOf(布尔型 b)
valueOf()方法用于获取表示指定布尔值的布尔实例。如果指定的布尔值为真，则此方法返回布尔值。真；如果为 false，则此方法返回布尔值。 FALSE。
此方法采用Boolean类型参数，并返回表示指定参数的布尔对象。
语法:
public static boolean valueOf(boolean b)
示例:
在本例中，我们将基元类型布尔值解析为布尔对象。我们用valueOf()方法得到布尔对象。
public class booleanDemo1
{
public static void main(String[] args)
{
boolean obj1 = true;
boolean obj2 = false;
Boolean obj3 = Boolean.valueOf(obj1);
Boolean obj4 = Boolean.valueOf(obj2);
System.out.println(obj3);
System.out.println(obj4);
}
}
4.valueOf(字符串 s)
valueOf()方法用于获取一个布尔值，该值由指定的字符串表示。它接受一个字符串参数，并返回一个由指定参数表示的布尔值。
语法:
public static boolean valueOf(String s)
示例:
public class booleanDemo1
{
public static void main(String[] args)
{
Boolean obj1 = Boolean.valueOf("True");
Boolean obj2 = Boolean.valueOf(null);
Boolean obj3 = Boolean.valueOf("StUdYtONiGhT");
Boolean obj4 = Boolean.valueOf("STUDYTONIGHT");
Boolean obj5 = Boolean.valueOf("studytonight");
System.out.println(obj1);
System.out.println(obj2);
System.out.println(obj3);
System.out.println(obj4);
System.out.println(obj5);
}
}
5. toString（布尔值 b）
此方法用于获取表示指定布尔值的字符串对象。如果指定的布尔值为真，则返回的字符串为“真”，否则返回字符串“假”。
它接受一个布尔值参数，并返回指定布尔值的字符串表示形式。下面给出了该方法的语法。
语法:
public static String toString(boolean b)
示例:
我们可以使用这个方法来获取Boolean类型值的字符串表示。在这个例子中，我们取两个保存布尔值的布尔变量，并使用 toString()方法获取它们的字符串值。见下面的例子。
public class booleanDemo1
{
public static void main(String[] args)
{
boolean obj1 = true;
boolean obj2 = false;
String s1 = Boolean.toString(obj1);
String s2 = Boolean.toString(obj2);
System.out.println(s1);
System.out.println(s2);
}
}
6.toString()
此方法返回一个表示该布尔值的字符串对象。如果该对象表示值为真，则返回一个等于“真”的字符串。否则，返回等于“假”的字符串。这不需要任何争论。
语法:
public String toString()
示例:
在这个例子中，我们使用toString()方法获得了布尔对象的字符串表示。
public class booleanDemo1
{
public static void main(String[] args)
{
Boolean obj1 = new Boolean("True");
Boolean obj2 = new Boolean(null);
Boolean obj3 = new Boolean("StUdYtONiGhT");
Boolean obj4 = new Boolean("STUDYTONIGHT");
Boolean obj5 = new Boolean("studytonight");
String s1 = obj1.toString();
String s2 = obj2.toString();
String s3 = obj3.toString();
String s4 = obj4.toString();
String s5 = obj5.toString();
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println(s5);
}
}
7. int hashcode（）
此方法用于获取布尔值的哈希代码。它返回一个布尔对象的哈希码值。它不接受任何参数，但返回一个表示布尔值哈希代码的 int 值。
这个方法包含在 Java 8 版本中。下面给出了该方法的语法。
语法:
public int hashCode()
示例:
让我们创建一个示例来获取布尔值的哈希代码。这里我们已经创建了几个布尔变量，用来获取不同的哈希代码值。
public class booleanDemo1
{
public static void main(String[] args)
{
Boolean obj1 = new Boolean("True");
Boolean obj2 = new Boolean(null);
Boolean obj3 = new Boolean("StUdYtONiGhT");
Boolean obj4 = new Boolean("STUDYTONIGHT");
Boolean obj5 = new Boolean("studytonight");
System.out.println(obj1.hashCode());
System.out.println(obj2.hashCode());
System.out.println(obj3.hashCode());
System.out.println(obj4.hashCode());
System.out.println(obj5.hashCode());
}
}
8.等于(对象对象)
equal()方法用于检查两个布尔对象是否代表相同的值。此方法用于比较两个布尔值，如果两者相等，则返回 true，否则返回 false。
它接受一个不应为 null 的参数，并返回一个布尔值 true 或 false。下面给出了该方法的语法。
语法:
boolean equals(Object obj)
示例:
让我们创建一个示例来比较两个布尔值是否具有相同的值。如果两个值相同，则返回 true。
public class booleanDemo1
{
public static void main(String[] args)
{
Boolean obj1 = new Boolean("True");
Boolean obj2 = new Boolean(null);
Boolean obj3 = new Boolean("StUdYtONiGhT");
Boolean obj4 = new Boolean("STUDYTONIGHT");
Boolean obj5 = new Boolean("studytonight");
System.out.println(obj1.equals(obj2));
System.out.println(obj2.equals(obj3));
System.out.println(obj3.equals(obj4));
System.out.println(obj4.equals(obj5));
System.out.println(obj5.equals(obj1));
}
}
9.比较
compareTo()方法用于比较一个布尔实例和另一个布尔实例。此方法在接受Boolean类型的单个参数的Comparable接口中指定。
如果两个对象表示相同的布尔值，则返回 0；如果此对象为真，而参数为假，则为正值；如果此对象表示 false，并且参数表示 true，则为负值。
语法:
public int compareTo(Boolean b)
示例:
让我们举个例子，用compareTo()比较两个布尔对象。这将根据对象比较返回一个 int 值。
public class booleanDemo1
{
public static void main(String[] args)
{
Boolean obj1 = new Boolean("True");
Boolean obj2 = new Boolean(null);
Boolean obj3 = new Boolean("StUdYtONiGhT");
Boolean obj4 = new Boolean("STUDYTONIGHT");
Boolean obj5 = new Boolean("studytonight");
System.out.println(obj1.compareTo(obj2));
System.out.println(obj2.compareTo(obj3));
System.out.println(obj3.compareTo(obj4));
System.out.println(obj4.compareTo(obj5));
System.out.println(obj5.compareTo(obj1));
}
}
10.int compare(布尔 x，布尔 y)
compare()方法用于比较两个布尔值。它接受两个布尔参数，如果两个值相等，则返回 0；负整数或正整数。下面给出了该方法的语法。
语法:
public static int compare(boolean x, boolean y)
示例:
让我们举一个比较两个布尔值并根据比较结果返回整数的例子。
public class booleanDemo1
{
public static void main(String[] args)
{
boolean obj1 = true;
boolean obj2 = false;
boolean obj3 = true;
boolean obj4 = false;
boolean obj5 = true;
System.out.println(Boolean.compare(obj1, obj2));
System.out.println(Boolean.compare(obj2, obj3));
System.out.println(Boolean.compare(obj3, obj4));
System.out.println(Boolean.compare(obj4, obj5));
System.out.println(Boolean.compare(obj5, obj1));
}
}
Java Character类
Character类是一个包装器，用于包装对象中基本类型字符的值。Character类的对象包含一个类型为字符的字段。
这个类提供了大量静态方法来确定字符的类别(小写字母、数字等)。)和用于将字符从大写转换为小写，反之亦然。
这个类位于 java.lang 包中，声明如下。
申报
public final class Character extends Object implements Serializable, Comparable<Character>
这里我们通过例子来解释Character类的方法。
1.伊斯雷尔(char ch)
此方法用于确定指定字符是否为字母。它返回真或假的布尔值。如果字符是字母，则返回 true，否则返回 false。它采用单个Character类型参数。下面给出了该方法的一般语法。
语法:
boolean isLetter(char ch)
示例:
让我们举个例子来检查指定的字符是否是字母。我们使用isLetter()方法来确保这一点。见下面的例子。
public class CharacterDemo1
{
public static void main(String[] args)
{
System.out.println(Character.isLetter('S'));
System.out.println(Character.isLetter('9'));
}
}
2.isdigt(char ch)
Character类提供了一个isDigit()方法来确定指定的字符是否是数字。如果指定的字符是数字，则返回 true，否则返回 false。
它采用单个Character类型参数。下面给出了该方法的一般语法。
语法:
boolean isDigit(char ch)
示例:
在这个例子中，我们检查指定的字符是否是数字。如果指定的字符是数字，则返回 true。
public class CharacterDemo1
{
public static void main(String[] args)
{
System.out.println(Character.isDigit('S'));
System.out.println(Character.isDigit('9'));
}
}
3.isWhitespace(char ch)
此方法用于确定指定字符是否为空格。如果字符是 Unicode 空格字符，则它是 Java 空白字符。如果字符是 Java 空白，则返回 true，否则返回 false。
它采用单个Character类型参数。下面给出了该方法的一般语法。
语法:
boolean isWhitespace(char ch)
示例:
我们可以使用isWhitespace()方法来检查指定的字符是否是空白，就像我们在下面的例子中所做的那样。
public class CharacterDemo1
{
public static void main(String[] args)
{
System.out.println(Character.isWhitespace('S'));
System.out.println(Character.isWhitespace(' '));
System.out.println(Character.isWhitespace('\n'));
System.out.println(Character.isWhitespace('\t'));
System.out.println(Character.isWhitespace(5));
System.out.println(Character.isWhitespace('5'));
}
}
4 . isppender case(char ch)
isUpperCase()方法用于确定指定字符是否为大写字符。如果指定的字符是大写字母，则返回 true，否则返回 false。
它采用单个Character类型参数。下面给出了该方法的一般语法。
语法:
booleanisUpperCase(char ch)
示例:
让我们举个例子来检查指定的字符是否是大写字母。
public class CharacterDemo1
{
public static void main(String[] args)
{
System.out.println(Character.isUpperCase('S'));
System.out.println(Character.isUpperCase('s'));
System.out.println(Character.isUpperCase(89));
}
}
5.ispower case(char ch)
此方法用于检查指定字符是否为小写字母。如果指定字符为小写，则返回 true，否则返回 false。下面给出了该方法的语法。
语法:
boolean isLowerCase(char ch)
示例:
要检查字符的小写，我们可以使用返回 true 的 isLowerCase()方法。
public class CharacterDemo1
{
public static void main(String[] args)
{
System.out.println(Character.isLowerCase('S'));
System.out.println(Character.isLowerCase('s'));
System.out.println(Character.isLowerCase(46));
}
}
6.toUpperCase(char ch)
此方法用于将字符参数转换为大写。它在转换为大写后返回一个字符。它只需要一个 char 类型的参数。下面给出了该方法的语法。
语法:
char toUpperCase(char ch)
示例:
如果我们想把一个字符转换成大写，那么我们可以使用这个方法，在转换成大写后返回一个字符。
public class CharacterDemo1
{
public static void main(String[] args)
{
System.out.println(Character.toUpperCase('s'));
System.out.println(Character.toUpperCase(45));
System.out.println(Character.toUpperCase(12));
}
}
7.托勒温案(char ch)
此方法用于将字符参数转换为小写字母。它在转换为小写后返回一个字符。它采用单Character类型参数。该方法的声明如下。
语法:
char toLowerCase(char ch)
示例:
我们正在创建一个将字符转换为小写的示例。它使用toLowerCase()方法进行字符大小写转换。
public class CharacterDemo1
{
public static void main(String[] args)
{
System.out.println(Character.toLowerCase('S'));
System.out.println(Character.toLowerCase(45));
System.out.println(Character.toLowerCase(12));
}
}
8.toString(char ch)
toString()方法用于获取表示指定字符的字符串对象。结果是长度为 1 的字符串，仅由指定的字符组成。
此方法以单个字符作为参数，并返回一个字符串。该方法的声明如下。
语法:
String toString(char ch)
示例:
public class CharacterDemo1
{
public static void main(String[] args)
{
System.out.println(Character.toString('S'));
System.out.println(Character.toString('a'));
}
}
9. charCount(内部代码点)
此方法用于确定表示指定字符所需的字符值的数量
如果指定的字符等于或大于 0x10000，它将 int 类型参数作为代码点并返回 2，否则返回 1。
语法:
public static intcharCount(int code)
示例:
让我们举一个例子来使用 charCount()方法，该方法将对代码点的字符进行计数。
public class CharacterDemo1
{
public static void main(String[] args)
{
int a = 0x9001;
int b = Character.charCount(a);
System.out.println(b);
}
}
10.charValue()
charValue()方法用于从 char 对象中获取一个原始 char 类型值。它返回这个字符对象的一个字符值。该方法的声明如下。
语法:
public char charValue()
示例:
在这个例子中，我们使用charValue()方法从角色对象中获取一个原始字符。
public class CharacterDemo1
{
public static void main(String[] args)
{
Character a = new Character('a');
char b = a.charValue();
System.out.println(b);
}
}
Java 反射
Java 反射 API
反射意味着软件自我分析的能力。在 Java 中，反射 API 提供了在运行时分析和更改类的运行时行为的工具。
例如，在运行时使用反射可以确定一个类支持什么方法、字段、构造器或修饰符。
java.lang.Class 类提供了用于获取元数据和操纵类运行时行为的方法。
java.lang 和 java.lang.reflect 包提供了许多用于反射的类，并获取特定类的元数据。
反射 API 的一个优点是，我们也可以操纵类的私有成员。
什么是反射包？
java.lang.reflect包封装了几个重要的接口和类。这些类和接口定义了用于反射的方法。
Java.lang.reflect 包的一些重要类
| 班级 | 它有什么作用？ |
| 排列 | 允许您动态创建和操作数组 |
| 构造器 | 提供有关类构造器的信息 |
| 田 | 提供有关字段的信息 |
| 方法 | 提供有关方法的信息 |
| 修饰语 | 提供有关类和成员访问修饰符的信息 |
| 代理 | 支持动态代理类 |
除了这些类之外java.lang.Class是反射 API 中使用的另一个非常重要的类。
反射的用途
- 开发 IDE
- 调试和测试工具
- 加载驱动并提供动态信息
反思的弊端
- 低性能
- 危险人物
- 违反 Oops 概念
Java Class类
Java 提供了一个类 class，该类包含获取类的元数据和操作类的运行时行为的方法。
要执行反射操作，我们必须使用 java.lang.Class ，它有创建对象的公共构造器。
类对象由 Java 虚拟机在加载类时自动构造，并通过调用类加载器中的 defineClass 方法来构造。
Java 类方法
| 方法 | 描述 |
| 公共字符串 getName() | 返回类名 |
| 用于名称(String类名)的公共静态类引发类未找到异常 | 加载类并返回Class类的引用。 |
| 公共对象 newInstance()引发实例化异常，IllegalAccessException | 创建新实例。 |
| 公共布尔 isInterface() | 检查它是否是接口。 |
| 公共布尔 isArray() | 检查它是否是数组。 |
| 公共布尔 isPrimitive() | 检查它是否是原始的。 |
| 公共类 getSuperclass() | 返回超Class类引用。 |
| 公共字段[] getDeclaredFields()引发安全异常 | 返回此类的字段总数。 |
| public Method[]getDeclaredMethods()引发 SecurityException | 返回此类的方法总数。 |
| 公共构造器[] getDeclaredConstructors()引发安全异常 | 返回此类的构造器总数。 |
| 公共方法 getDeclaredMethod(字符串名称，类[]Parameter类型)引发 NoSuchMethodException，SecurityException | 返回方法类实例。 |
| 公共类>[]getclass() | 数组表示该类公共成员的类对象数组表示该类公共成员的类对象数组 |
| 公共字段[] getFields()引发安全异常 | 表示公共字段的字段对象数组 |
| 公共方法[] getMethods()引发 SecurityException | 表示此类公共方法的方法对象数组 |
| 公共构造器> [] getConstructors()抛出 SecurityException | 表示此类公共构造器的构造器对象数组 |
| 公共方法 getMethod(字符串名称，类>...Parameter类型) | 匹配指定名称和Parameter类型的方法对象 |
如何检索类的对象？
我们可以使用 class 类来获取一个类的对象。下面列出了男子气概的三种方式:
- Object.getClass()
- 使用。类语法
- Class.forName()
1.如果我们有一个类的实例，那么我们可以使用getClass()方法获得它的限定名。此方法在对象类中定义。
举个例子，我们使用 getclass 方法获取类名。实例可以是任何自定义类或内置类。
class Employee{
int empId;
String name;
}
class Demo{
public static void main(String[] args) throws ClassNotFoundException {
Employee employee = new Employee();
// employee object
Class name = employee.getClass();
System.out.println(name);
// string object
name = "hello".getClass();
System.out.println(name);
}
}
雇员类 java.lang.String
2.如果类型可用但没有实例，则可以通过使用获得一个类。类到类型的名称。这也是获取基元类型的类的最简单方法。
class Employee{
int empId;
String name;
}
class Demo{
public static void main(String[] args) throws ClassNotFoundException {
// Employee Type
Class name = Employee.class;
System.out.println(name);
// string Type
name = String.class;
System.out.println(name);
}
}
雇员类 java.lang.String
3.如果我们有一个类的全限定名，我们可以使用静态方法Class.forName()得到相应的类。此方法不能用于基元类型。见下面的例子。
class Employee{
int empId;
String name;
}
class Demo{
public static void main(String[] args) throws ClassNotFoundException {
// Employee class
Class name = Class.forName("Employee");
System.out.println(name);
// String class
name = Class.forName("java.lang.String");
System.out.println(name);
}
}
雇员类 java.lang.String
在下一个主题中，我们将讨论如何获取类、方法、字段等的元数据。
Java Class类
在前一个主题中，我们讨论了如何在运行时使用各种方法加载类。在这里，我们将看到如何获取该类的元数据、方法和字段。
Class是 java.lang 包中的最后一个类，它扩展了 Object 类。此类的实例表示运行的 Java 应用中的类和接口。它用于在运行时分析和更改类的动态行为。
Java.lang.Class 方法
这个类定义了几个方法，使用这些方法我们可以在运行时获得类的方法、构造器、修饰符和成员的信息。
续见()
此方法以类或接口的完全限定名作为参数，并返回与之关联的类的实例。
语法
static **Class**< ?> forName(String *className*)
示例:获取类元数据
要获取类的元数据，首先需要使用class.forName()方法加载类，然后使用 class 方法。在这个例子中，我们使用getName()方法获取类名，getDeclaredFields()获取该类的所有字段。见下面的例子。
package myjavaproject;
import java.util.Arrays;
// Employee Class
class Employee{
// Fields
int empId;
String name;
// Constructor
Employee(int empId, String name){
this.empId = empId;
this.name = name;
}
// Method
void showInfo() {
System.out.println("Employee Id: "+empId);
System.out.println("Employee Name: "+name);
}
}
class Demo{
public static void main(String[] args) throws ClassNotFoundException {
// Employee class
Class name = Class.forName("myjavaproject.Employee");
// Get class Name
System.out.println(name.getName());
// Get Package
System.out.println(name.getPackageName());
System.out.println(name.getTypeName());
Arrays.stream(name.getDeclaredConstructors()).forEach(System.out::println);
Arrays.stream(name.getDeclaredFields()).forEach(System.out::println);
Arrays.stream(name.getDeclaredMethods()).forEach(System.out::println);
}
}
我的 myjavaproject。员工 my javap project my javap project。员工 myjavaproject。Employee(int，Java . lang . String)int myjavaproject。employee . empid Java . lang . string my javap project。employee . name void my javap project。Employee.showInfo()
示例:获取字段元数据
为了处理类字段，Java 提供了一个位于 java.lang.reflect 包中的 Field 类。此类包含有助于获取字段元数据的方法。在这个例子中，您可以看到我们使用了 class.forName 来加载类，然后使用 Field 类来获取类的元数据。
package myjavaproject;
import java.lang.reflect.Field;
// Employee Class
class Employee{
// Fields
int empId;
String name;
// Constructor
Employee(int empId, String name){
this.empId = empId;
this.name = name;
}
// Method
void showInfo() {
System.out.println("Employee Id: "+empId);
System.out.println("Employee Name: "+name);
}
}
class Demo{
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
// Employee class
Class name = Class.forName("myjavaproject.Employee");
// Get Fields metadata
Field[] field = name.getDeclaredFields();
for(Field f: field) {
System.out.print(f.getType()+" ");
System.out.println(f.getName());
System.out.println(f.getModifiers());
}
}
}
int empId 0 类 java.lang.String 名称 0
示例:获取方法元数据
为了处理类方法，Java 提供了一个位于 java.lang.reflect 包中的方法类。此类包含有助于获取方法元数据的方法。在这个例子中，您可以看到我们使用了 class.forName 来加载类，然后使用 Method 类来获取方法的元数据。
import java.lang.reflect.Method;
// Employee Class
class Employee{
// Fields
int empId;
String name;
// Constructor
Employee(int empId, String name){
this.empId = empId;
this.name = name;
}
// Method
void showInfo() {
System.out.println("Employee Id: "+empId);
System.out.println("Employee Name: "+name);
}
}
class Demo{
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
// Employee class
Class name = Class.forName("myjavaproject.Employee");
// Get method metadata
Method[] method = name.getDeclaredMethods();
for(Method m: method) {
System.out.println(m);
System.out.println(m.getDefaultValue());
System.out.println(m.getModifiers());
System.out.println(m.getName());
System.out.println(m.getParameterCount());
System.out.println(m.getReturnType());
}
}
}
void myjavaproject。employee . ShowInfo()null 0 ShowInfo 0 无效
示例:获取构造器元数据
一个类可能有几个构造器，包括参数化的和非参数化的。Java 反射提供了由方法组成的构造器类，可以用来获取构造器的元数据。在这个例子中，我们使用构造器类及其方法来获取构造器的元数据。请看下面的例子。
package myjavaproject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Parameter;
// Employee Class
class Employee{
// Fields
int empId;
String name;
// Constructor
Employee(int empId, String name){
this.empId = empId;
this.name = name;
}
// Method
void showInfo() {
System.out.println("Employee Id: "+empId);
System.out.println("Employee Name: "+name);
}
}
class Demo{
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
// Employee class
Class name = Class.forName("myjavaproject.Employee");
// Get method metadata
Constructor[] constructor = name.getDeclaredConstructors();
for(Constructor c: constructor) {
System.out.println(c);
System.out.println(c.getModifiers());
System.out.println(c.getName());
System.out.println(c.getParameterCount());
System.out.println(c.getDeclaringClass());
Parameter[] parameters = c.getParameters();
for(Parameter p : parameters) {
System.out.println(p);
}
Class[] pt = c.getParameterTypes();
for(Class s : pt) {
System.out.println(s);
}
}
}
}
我的 myjavaproject。Employee(int，Java . lang . string)0 my javaproject。员工 2 类 myjavaproject。employee int arg 0 Java . lang . string arg 1 int class Java . lang . strings
getConstructors()和 getDeclaredConstructors()
getConstructors()方法返回表示调用对象的所有公共构造器的构造器对象数组。记住，这个方法只返回公共构造器。如果你想看到一个类的所有声明的构造器，那么使用getDeclaredConstructors()。以下是两者的一般语法，
**Constructor**< ?>[] *getConstructors*();
**Constructor**< ?>[] *getDeclaredConstructors*();
示例:getConstructors()和 getDeclaredConstructors()方法
这两种方法都用于获取类构造器，但是getConstructors()只返回公共构造器，而getDeclaredConstructors()返回所有可用的构造器。
import java.lang.reflect.*;
class Student
{
public Student(){}
public Student(String name){}
}
class Test
{
public static void main(String args[])
{
try
{
Class c = Class.forName("Student");
Constructor< Student>[] ct = c.getConstructors();
for(int i=0; i< ct.length; i++)
{ System.out.println(ct[i]); }
Constructor< Student>[]cdt = c.getDeclaredConstructors();
for(int i=0;i< cdt.length;i++)
{ System.out.println(cdt[i]);}
}
catch(Exception e)
{ e.printStackTrace();}
}
}
公共学生公共学生公共学生公共学生
getMethods()和 getDeclaredMethods()
getMethods()方法返回 method 对象的数组，该数组反映调用对象的所有公共方法。getDeclaredMethods()只返回调用类对象的声明方法。两者语法如下:
**Method**< ?>[] *getMethods*();
**Method**< ?>[] *getDeclaredMethods*();
示例:getDeclaredMethods()方法
让我们举一个例子，在这个例子中，我们使用getDeclaredMethods()方法来获取类中所有声明的方法。见下面的例子。
import java.lang.reflect.*;
class Student
{
public void show(){}
void display(){}
}
class Test
{
public static void main(String args[])
{
try
{
Class c = Class.forName("Student");
Method md[] = c.getDeclaredMethods();
for(int i=0; i< md.length; i++ )
{ System.out.println(md[i]); }
}
catch(Exception e)
{ e.printStackTrace();}
}
}
公共 void Student.show()
getFields()和 getDeclaredFields()
getFields()返回一个包含 Field 对象的数组，该数组反映了该 class 对象表示的类或接口的所有可访问的公共成员。getDeclaredFields()返回一个字段对象数组，该数组反映了该类对象所代表的类或接口所声明的所有字段。
**Field**< ?>[] *getFields*();
**Field**< ?>[] *getDeclaredFields*();
示例:getFields()和 getDeclaredFields()方法
要获取一个类的字段，我们可以使用getFields()或getDeclaredFields()方法。除了 getFields 只返回公共字段之外，两者都返回字段。见下面的例子。
import java.lang.reflect.*;
class Student
{
public String name;
int roll;
}
class Test
{
public static void main(String args[])
{
try
{
Class c = Class.forName("Student");
Field ff[] = c.getFields();
for(int i=0; i< ff.length; i++)
{ System.out.println(ff[i]); }
Field f[] = c.getDeclaredFields();
for(int i=0;i< f.length; i++)
{ System.out.println(f[i]); }
}
catch(Exception e)
{ e.printStackTrace();}
}
}
public Java . lang . string student . name public Java . lang . string student . name int student . roll
数据库编程
JDBC 简介
原文：https://www.studytonight.com/java/introduction-to-jdbc.php
Java 数据库连接(JDBC) 是一个应用编程接口(API) ，用于连接 Java 应用和数据库。JDBC 用于与各种类型的数据库交互，如甲骨文、微软 Access、我的 SQL 和 SQL Server。JDBC 也可以定义为关系数据库和 Java 编程之间的独立于平台的接口。它允许 java 程序执行 SQL 语句并从数据库中检索结果。
JDBC API 由用于执行各种操作的类和方法组成，如:连接、读取、写入和在数据库中存储数据。在本教程中，我们将通过例子学习 JDBC。
您可以通过下图了解 JDBC 如何将 Java 应用连接到数据库。
JDBC 4.0 有什么新功能
Java 引入了 JDBC 4.0 ，这是 JDBC 的高级规范的新版本。它提供了以下高级功能
- 连接管理
- 驱动界面的自动加载。
- 更好的异常处理
- 支持大型对象
- SQL 查询中的注释。
JDBC 4.1
JDBC 4.1 版本是随 Java SE 7 一起推出的，包括以下功能:
- 允许使用资源试用语句自动关闭连接、结果集等类型的资源。
- 引入了行集工厂接口和行集提供程序类来创建您的 JDBC 驱动支持的所有类型的行集。
JDBC 4.2
版本与 Java SE 8 一起推出，包括以下功能:
- REF_CURSOR 支持。
- 增加了一个界面Java . SQL . drive traction
- 增加了一个接口 java.sql.SQLType
- 增加了一个枚举 java.sql.JDBCType
- 添加对大量更新计数的支持
- 改进现有接口:驱动、驱动管理、数据库元数据。
- 为 RowSet1.2 增强的接口和类:
JDBC 4.3
- 增加了对查询文字和简单标识符的语句的支持
- 增加了分片支持
- 增强的连接能够向驱动提供一个请求(一个独立的工作单元)开始或结束的提示
- 增强的数据库元数据，用于确定是否支持分片
- 向驱动管理器添加了方法驱动，以返回当前已加载且可用的 JDBC 驱动流
JDBC 司机
需要 JDBC 驱动来建立应用和数据库之间的连接。它还有助于处理 SQL 请求和生成结果。以下是 JDBC 提供的不同类型的驱动，应用根据应用的场景和类型使用这些驱动。
- 1 型驱动或 JDBC-ODBC 桥
- 类型 2 驱动或本地 API 部分 Java 驱动
- 3 类驱动或网络协议驱动
- 4 型驱动器或薄型驱动器
JDBC-ODBC 桥
Type-1 驱动充当 JDBC 和其他数据库连接机制(ODBC)之间的桥梁。该驱动将 JDBC 调用转换为 ODBC 调用，并将请求重定向到 ODBC 驱动。
注:在 Java 8 中，JDBC-ODBC 桥已经移除。
优势
- 使用方便
- 允许轻松连接到 ODBC 驱动支持的所有数据库。
劣势
- 执行时间慢
- 依赖于 ODBC 驱动。
- 使用 Java 本地接口(JNI)进行 ODBC 调用。
本机 API 驱动
这种类型的驱动利用了数据库特定的本地客户端 API 上的 Java 本地接口(JNI)调用。这些本地客户端 API 通常用 C 和 C++编写。
优势
- 与1 型驱动器相比速度更快
- 包含附加功能。
劣势
- 需要本机库
- 应用成本增加
网络协议驱动
该驱动将 JDBC 调用转换为独立于数据库服务器和中间件服务器特定的调用。中间件服务器进一步将 JDBC 调用转换为数据库特定的调用。
优势
- 不需要安装任何本机库。
- 数据库独立性。
- 提供从一个数据库切换到另一个数据库的功能。
劣势
- 由于网络呼叫数量增加，速度变慢。
瘦驱动
这个驱动被称为纯 Java 驱动，因为。这个驱动直接与数据库交互。它不需要任何本机数据库库，这就是它也被称为瘦驱动的原因。
优势
- 不需要任何本机库。
- 不需要任何中间件服务器。
- 性能优于其他驱动。
劣势
- 由于网络呼叫数量增加，速度变慢。
驱动管理器类
In Java, the DriverManager class it an interface between the User and the Driver. This class is used to have a watch on driver which is been used for establishing the connection between a database and a driver. The DriverManager class have a list of Driver class which are registered and are called as DriverManager.registerDriver().
| 没有。 | 方法 | 描述 |
| one | 公共静态无效注册表驱动(驱动驱动) | 它用于向驱动管理器注册驱动。 |
| Two | 公共静态无效注销驱动 | 它用于使用驱动管理器注销驱动。 |
| three | 公共静态连接 getConnection(字符串 Url) | 它用于建立与给定网址的连接。 |
| four | 公共静态连接获取连接(字符串网址、字符串用户名、字符串密码) | 它用于建立与给定网址、用户名和密码的连接。 |
连接接口
在 Java 中，连接接口用于创建应用和数据库之间的会话。该接口包含语句、准备好的语句和数据库元数据。连接对象用于语句和数据库元数据。提交()、回滚()等..是连接接口的一些方法。
| 没有。 | 方法 | 描述 |
| one | 公共语句 createStatement() | 它用于创建执行 SQL 查询的语句对象。 |
| Two | 公共语句创建状态(intresultSetType，intresultSetConcurrency) | 它用于根据给定的类型和并发性为结果集创建对象。 |
| three | 公共 void setAutoCommit(布尔状态) | 它用于设置提交状态。默认情况下，它总是正确的。 |
| four | 公共无效提交() | 它用于永久保存已提交或回滚的更改 |
| five | 公共 void 回滚() | 它用于永久删除已提交或回滚的更改 |
| six | 公共无效关闭() | 它用于永久删除已提交或回滚的更改 |
语句接口
在 Java 中，语句接口用于使用数据库执行查询。这个接口是结果集的工厂。用于获取结果集的对象。下面给出了这个接口的方法。
| 没有。 | 方法 | 描述 |
| one | public result setexecutequery(SQL 字符串) | 它用于执行选择查询 |
| Two | public inteexec update(SQL 字符串) | 它用于执行任何指定的查询 |
| three | 公共布尔执行(字符串 sql) | 当需要多个结果时使用。 |
| four | public int[] executeBatch() | 它用于执行该批命令。 |
结果集接口
在 Java 中，结果集接口用于维护指向表的一行的指针。在开始时，指针在第一行之前。在 createStatement(int，int)中，可以使用类型 _ 滚动 _ 不敏感或类型 _ 滚动 _ 敏感来向前和向后移动对象。下面给出了这个接口的方法。
| 没有。 | 方法 | 描述 |
| one | 公共布尔 next() | 它用于将光标从当前位置移动到下一个位置。 |
| Two | 公共布尔值上一个() | 它用于将光标从当前位置移动到上一个位置。 |
| three | 公共布尔优先() | 它用于将光标从当前位置移动到第一个位置。 |
| four | public booleanlast() | 它用于将光标从当前位置移动到最后一个位置。 |
| five | 公共 booleanalash(int row) | 它用于将光标从当前位置移动到指定位置。 |
| six | 公共 booleanrelative(int row) | 它用于将光标从当前位置移动到相对行号。 |
| seven | public(非列索引) | 它用于从指定位置获取数据。 |
| eight | public intent(string column name) | 它用于从当前行的指定列名中获取数据。 |
| nine | public string string(int column index) | 它用于从当前行的指定列名中获取整数形式的数据。 |
| Ten | public string string(string column index) | 它用于以字符串的形式从当前行的指定列名中获取数据。 |
PreparedStatement 接口
在 Java 中，PreparedStatement 接口是语句的子接口。它主要用于参数化查询。一个问号(？)传递给值。该问号的值将由 PreparedStatement 设置。下面给出了这个接口的方法。
| 没有。 | 方法 | 描述 |
| one | public void setInt(intparamIndex，int value) | 它用于设置给定参数索引的整数值。 |
| Two | public void setstring(int param index，String value) | 它用于设置给定参数索引的字符串值。 |
| three | 公共 void setFloat(intparamIndex，Float 值) | 它用于设置给定参数索引的浮点值。 |
| four | public void set double(int param index，double value) | 它用于为给定的参数索引设置双精度值。 |
| five | public intexecuteupdate() | 它用于执行查询。 |
| six | public ResultSetexecuteQuery() | 它用于执行选择查询。 |
结果集元数据接口
结果集元数据接口用于从结果集对象获取元数据。元数据是关于数据的数据。下面给出了这个接口的方法。
| 没有。 | 方法 | 描述 |
| one | public intgetColumnCount()引发 SQLException | 它用于获取列的总数。 |
| Two | 公共字符串 getColumnName(int 索引)引发 SQLException | 它用于获取指定列索引的列名。 |
| three | public stringetcolumntypename(int index)引发 SQLException | 它用于获取指定索引的列名。 |
| four | public StringgetTableName(int index)引发 SQLException | 它用于从指定的列索引中获取表的名称 |
JDBC API
JDBC 原料药主要分为两个包。每次当我们使用 JDBC 时，我们必须导入这些包来使用我们应用中的类和接口。
java.sqljavax.sql
Java.sql 包
这个包包括执行几乎所有 JDBC 操作类和接口，例如创建和执行 SQL 查询。
java.sql包的重要类和接口
| 类/接口 | 描述 |
| java.sql.BLOB | 提供对 BLOB(二进制大对象)SQL 类型的支持。 |
| java.sql.Connection | 创建与特定数据库的连接 |
| java.sql.CallableStatement | 执行存储过程 |
| java.sql.CLOB | 提供对 CLOB(字符大对象)SQL 类型的支持。 |
| java.sql.Date | 为日期 SQL 类型提供支持。 |
| java.sql.Driver | 使用驱动管理器创建驱动实例。 |
| java.sql.DriverManager | 这个类管理数据库驱动。 |
| java.sql.PreparedStatement | 用于创建和执行参数化查询。 |
| java.sql.ResultSet | 它是一个接口，提供逐行访问结果的方法。 |
| java.sql.Savepoint | 在事务中指定保存点。 |
| java.sql.SQLException | 封装所有与 JDBC 相关的异常。 |
| java.sql.Statement | 该接口用于执行 SQL 语句。 |
| 数据库元数据 | 关于数据库整体的综合信息。 |
| 驾驶练习 | 当驱动希望得到驱动管理员的通知时，必须实现的接口。 |
| 元数据 | 一个对象，可用于获取有关结果集对象中列的类型和属性的信息。 |
| rowid。rowid | 一个 SQL ROWID 值在 Java 编程语言中的表示(映射)。 |
| 保存点 | 保存点的表示，它是当前事务中的一个点，可以从 Connection.rollback 方法中引用。 |
| SQL data(SQL data) | 用于将 SQL 用户定义类型(UDT)自定义映射到 Java 编程语言类的接口。 |
| SQLInput | 包含表示 SQL 结构化类型或 SQL 独特类型实例的值流的输入流。 |
| sql 输出 | 用于将用户定义类型的属性写回数据库的输出流。 |
| SQLType | 用于标识通用 SQL 类型的对象，称为 JDBC 类型或供应商特定的数据类型。 |
| sql xml | 用于 SQL XML 类型的 JavaTM 编程语言中的映射。 |
| 声明 | 用于执行静态 SQL 语句并返回其产生的结果的对象。 |
| 结构体 | Java 编程语言中用于 SQL 结构化类型的标准映射。 |
| 包装材料 | JDBC 类的接口，当所讨论的实例实际上是代理类时，该接口提供检索委托实例的能力。 |
Javax.sql 包
这个包也被称为 JDBC 扩展 API。它提供了访问服务器端数据的类和接口。
javax.sql包的重要类和接口
| 类/接口 | 描述 |
| javax.sql.ConnectionEvent | 提供事件发生的信息。 |
| javax.sql.ConnectionEventListener | 用于注册池连接对象生成的事件。 |
| javax.sql.DataSource | 表示应用中使用的数据源接口。 |
| javax.sql.PooledConnection | 提供对象来管理连接池。 |
| 公共数据源 | 定义数据源、XADataSource 和 ConnectionPoolDataSource 之间通用方法的接口。 |
| 行集 | 该接口增加了对 JavaBeans 组件模型的 JDBC API 的支持。 |
| RowSetInternal | 行集对象实现的接口，以便将其自身呈现给行集读取器或行集写入器对象。 |
| RowSetListener | 必须由组件实现的接口，该组件希望在行集对象的生命周期中发生重大事件时得到通知。 |
| RowSetMetaData | 包含行集对象中列信息的对象。 |
| RowSetReader | 断开连接的行集对象调用的工具，用数据行填充自己。 |
| RowSetWriter | 实现行集编写器接口的对象，称为编写器。 |
| statesmenteventlistener | 一个对象，它注册在语句池中的 PreparedStatements 上发生的事件的通知。 |
| XAConnection | 为分布式事务提供支持的对象。 |
| XADataSource | 内部使用的连接对象的工厂。 |
将 Java 应用连接到数据库的步骤
原文：https://www.studytonight.com/java/steps-to-connect-to-database-in-java.php
以下 5 个步骤是使用 JDBC 将 Java 应用与数据库连接的基本步骤。
- 注册驱动
- 创建连接
- 创建 SQL 语句
- 执行 SQL 语句
- 关闭连接
注册驱动
它首先是建立 JDBC 联系的一个重要部分。JDBC API 提供了一种方法Class.forName()，用于显式加载驱动类。例如，如果我们想要加载一个 jdbc-odbc 驱动，那么我们可以这样调用它。
向 JDBC-ODBC 驱动注册的示例
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
创建连接
在步骤 1 中注册并加载驱动后，现在我们将使用 DriverManager 类的getConnection()方法创建一个连接。这个方法有几个重载方法，可以根据需求使用。基本上，它需要数据库名称、用户名和密码来建立连接。下面给出了该方法的语法。
句法
getConnection(String url)
getConnection(String url, String username, String password)
getConnection(String url, Properties info)
这是一个与 Oracle 驱动建立连接的示例
Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE","username","password");
import java.sql.*;
class Test {
public static void main(String[] args) {
try {
//Loading driver
Class.forName("oracle.jdbc.driver.OracleDriver");
//creating connection
Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "username", "password");
Statement s = con.createStatement(); //creating statement
ResultSet rs = s.executeQuery("select * from Student"); //executing statement
while (rs.next()) {
System.out.println(rs.getInt(1) + " " + rs.getString(2));
}
con.close(); //closing connection
} catch (Exception e) {
e.printStacktrace();
}
}
}
创建 SQL 语句
在这一步中，我们将使用 create statement()方法创建语句对象。它用于执行 sql 查询，并在连接类中定义。下面给出了该方法的语法。
句法
public Statement createStatement() throws SQLException
创建 SQL 语句的示例
Statement s=con.createStatement();
执行 SQL 语句
创建语句后，现在使用语句界面的executeQuery()方法执行。此方法用于执行 SQL 语句。下面给出了该方法的语法。
句法
public ResultSet executeQuery(String query) throws SQLException
执行 SQL 语句的示例
在这个例子中，我们正在执行一个 sql 查询，从用户表中选择所有的记录并存储到 resultset 中，resultset 进一步用于显示这些记录。
ResultSet rs=s.executeQuery("select * from user");
while(rs.next())
{
System.out.println(rs.getString(1)+" "+rs.getString(2));
}
关闭连接
这是最后一步，包括关闭我们在前面步骤中打开的所有连接。执行完 SQL 语句后，您需要关闭连接并释放会话。连接界面的close()方法用于关闭连接。
句法
public void close() throws SQLException
关闭连接的示例
con.close();
现在，让我们将所有这些步骤组合成一个示例，并创建一个完整的 JDBC 连通性示例。
示例:所有步骤进入一个地方
import java.sql.*;
class Test {
public static void main(String[] args) {
try {
//Loading driver
Class.forName("oracle.jdbc.driver.OracleDriver");
//creating connection
Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "username", "password");
Statement s = con.createStatement(); //creating statement
ResultSet rs = s.executeQuery("select * from Student"); //executing statement
while (rs.next()) {
System.out.println(rs.getInt(1) + " " + rs.getString(2));
}
con.close(); //closing connection
} catch (Exception e) {
e.printStacktrace();
}
}
}
使用 JDBC 类型 1 驱动连接到 Access 数据库
原文：https://www.studytonight.com/java/connecting-to-access.php
使用 JDBC-ODBC 桥(类型 1)驱动将 Java 应用与 Access 数据库连接起来。您需要遵循以下步骤。
注意:在 Java 8 中，JDBC-ODBC 桥已经被移除。不再支持它。
创建 DSN 名称
-
Go to control panel
-
Go to Administrative tools
-
Select Data Source(ODBC)
-
Add new DSN name, select add
-
Select Access driver from the list, click on finish
-
Give a DSN name, click ok
注意:这里我们展示了这个在 Window 7 os 中创建 DSN 的例子。对于其他操作系统，你需要做一些小的改动。
是时候举个例子了！
我们假设您已经在 access 数据库中创建了一个具有 sid 和名称列名的学生表。
import java.sql.*;
class Test
{
public static void main(String []args)
{
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con = DriverManager.getConnection("jdbc:odbc:Test", "", "");
Statement s=con.createStatement(); //creating statement
ResultSet rs=s.executeQuery("select * from student"); //executing statement
while(rs.next()){
System.out.println(rs.getInt(1)+" "+rs.getString(2));
}
con.close(); //closing connection
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
Java：使用瘦驱动连接到 Oracle 数据库
原文：https://www.studytonight.com/java/connecting-to-oracle.php
使用瘦驱动将 Java 应用与 Oracle 数据库连接。您需要遵循以下步骤
-
加载驱动类:oracle 数据库的驱动类为Oracle . JDBC . Driver . oracledriver，
Class.forName("oracle.jdbc.driver.OracleDriver")方法用于加载 Oracle 数据库的驱动类。 -
Create Connection: For creating a connection you will need a Connection URL. The Connection URL for Oracle is
You will also require Username and Password of your Oracle Database Server for creating connection.
-
加载 jar 文件:要将您的 java 应用与 Oracle 连接，您还需要加载
ojdbc14.jar文件。这个文件可以通过两种方式加载。-
Copy the jar file into
C:\Program Files\Java\jre7\lib\extfolder.或者，
-
将其设置到类路径中。更多详情参见 如何设置类路径
-
注:这里讨论的是 Oracle 10g 作为数据库。对于其他版本的甲骨文，你将需要做一些小的改变在连接网址。
是时候举个例子了！
让我们看看执行简单操作的程序，比如在数据库表上创建、插入和选择。
在 Oracle 数据库中创建一个表
使用下面的 SQL 命令在 oracle 数据库中创建一个表学生。这个表有两列:sid 和 sname。
create table Student(sid number(10),sname varchar2(20));
在表格中插入一些记录
创建表后，现在使用下面的 sql 命令将两条记录插入表中。这里，我们插入了名为两行的 adam 和 abhi。
insert into Student values(101,'adam');
insert into Student values(102,'abhi');
JDBC 示例:访问记录
在上面的例子中，我们使用 SQL 命令插入了两条记录。现在我们使用 JDBC Java 应用获取这些记录。
import java.sql.*;
class Test
{
public static void main(String []args)
{
try{
//Loading driver
Class.forName("oracle.jdbc.driver.OracleDriver");
//creating connection
Connection con = DriverManager.getConnection
("jdbc:oracle:thin:@localhost:1521:XE","username","password");
Statement s=con.createStatement(); //creating statement
ResultSet rs=s.executeQuery("select * from Student"); //executing statement
while(rs.next()){
System.out.println(rs.getInt(1)+" "+rs.getString(2));
}
con.close(); //closing connection
}catch(Exception e){
e.printStackTrace();
}
}
}
101 个男人 102 个 abhi
示例:插入记录
我们可以使用 JDBC 使用 Java 应用将数据插入到表中。这里我们使用的是前一主题中讨论过的 Prepared 语句和参数化查询。
import java.sql.*;
class Test
{
public static void main(String []args)
{
try{
//Loading driver...
Class.forName("oracle.jdbc.driver.OracleDriver");
//creating connection...
Connection con = DriverManager.getConnection
("jdbc:oracle:thin:@localhost:1521:XE","username","password");
PreparedStatement pst=con.prepareStatement("insert into Student values(?,?)");
pst.setInt(1,104);
pst.setString(2,"Alex");
pst.executeUpdate();
con.close(); //closing connection
}catch(Exception e){
e.printStackTrace();
}
}
}
使用瘦驱动连接到 MySQL 数据库
原文：https://www.studytonight.com/java/connecting-to-mysql.php
使用瘦驱动连接 Java 应用和 MySQL 数据库。您需要遵循以下步骤
-
加载驱动类:MySQL 数据库的驱动类为 com.mysql.jdbc.Driver ，
Class.forName("com.mysql.jdbc.Driver")方法用于加载 MySQL 数据库的驱动类。 -
Create Connection: For creating a connection you will need a Connection URL. The Connection URL for MySQL is
You will also require Username and Password of your MySQL Database Server for creating connection.
-
加载 jar 文件:要将你的 java 应用与 MySQL 连接起来，你还需要加载
mysql-connector.jar文件。这个文件可以通过两种方式加载。-
Copy the jar file into
C:\Program Files\Java\jre7\lib\extfolder.或者，
-
将其设置到类路径中。更多详情参见 如何设置类路径
-
是时候举个例子了！
让我们看看执行简单操作的程序，比如在数据库表上创建、插入和选择。
在 MySQL 数据库中创建一个表
使用下面的 SQL 命令在 mysql 数据库中创建一个表学生。该表有两列:sid 和 name。
create table Student(sid int(10),name varchar(20));
在表格中插入一些记录
创建表后，现在使用下面的 sql 命令将两条记录插入表中。这里，我们插入了名为两行的 adam 和 abhi。
insert into Student values(102,'adam');
insert into Student values(103,'abhi');
示例:访问记录
在上面的例子中，我们使用 SQL 命令插入了两条记录。现在我们使用 JDBC Java 应用获取这些记录。
import java.sql.*;
class Test
{
public static void main(String []args)
{
try{
//Loading driver
Class.forName("com.mysql.jdbc.Driver");
//creating connection
Connection con = DriverManager.getConnection
("jdbc:mysql:/ /localhost:3306/test","username","password");
Statement s = con.createStatement(); //creating statement
ResultSet rs = s.executeQuery("select * from Student"); //executing statement
while(rs.next()){
System.out.println(rs.getInt(1)+" "+rs.getString(2));
}
con.close(); //closing connection
}catch(Exception e){
e.printStackTrace();
}
}
}
102 个男人 103 个 abhi
示例:插入记录
我们可以使用 Java 应用将数据插入到表中。这里我们使用准备语句和参数化查询来执行 SQL 查询。 executeUpdate() 方法用于执行插入查询。见下面的例子。
import java.sql.*;
class Test
{
public static void main(String []args)
{
try{
//Loading driver
Class.forName("com.mysql.jdbc.Driver");
//creating connection
Connection con = DriverManager.getConnection
("jdbc:mysql:/ /localhost:3306/test","username","password");
PreparedStatement pst=con.prepareStatement("insert into Student values(?,?)");
pst.setInt(1,104);
pst.setString(2,"Alex");
pst.executeUpdate();
con.close(); //closing connection
}catch(Exception e){
e.printStackTrace();
}
}
}
JDBC MongoDB 连接
原文：https://www.studytonight.com/java/connecting-to-mongodb.php
在本教程中，我们将讨论 Java 应用和 MongoDB 之间的数据库连接。MongoDB 是一个基于文档的数据库，用于将数据存储为 JSON 格式，而不是表或关系。它与关系数据库完全不同，比如:mysql。你可以从我们最新的教程 MongoDB 教程中了解 MongoDB。
现在让我们开始学习连接过程。在开始之前，请确保您的计算机系统中安装了 mongoDB。这些是连接时应该遵循的一些先决条件。
先决条件
- 使用 MongoDB 27017 的默认端口在本地主机上运行的 MongoDB。参见安装 Mongodb 安装步骤。
- MongoDB 驱动。
安装 mongodb 后，拥有 MongoDB 驱动也很重要。所以要得到这些，你可以访问官方网站 MongoDB Java Driver 或者从我们的网站下载 Jar 文件。将这个 JAR 文件保存到您的 java 应用目录中。
注意:【mongodb 连接不需要使用 JDBC API，它的 API 是完全独立的，不需要任何其他外部库。
以下是 Java 应用连接 mongodb 数据库的基本步骤。
创建 MongoDB 实例
您可以在没有任何参数的情况下实例化 MongoClient 对象，以连接到在端口:27017 上的本地主机上运行的 MongoDB 实例。使用以下代码。
MongoClient mongoClient = MongoClients.create();
您可以指定 mongodb 主机和运行端口，以防 mongodb 在不同的端口上运行。
MongoClient mongoClient = MongoClients.create("mongodb://hostOne:27017");
访问数据库
创建 mongoDB 实例后，使用其getDatabase()方法通过将数据库名称指定给getDatabase()方法来访问数据库。如果数据库不存在，MongoDB 会在您第一次存储该数据库的数据时创建该数据库。例如，我们正在连接到今晚研究数据库。
MongoDatabase database = mongoClient.getDatabase("studytonight");
访问收藏
创建 mongoDB 数据库后，使用其getCollection()方法通过指定名称来访问集合。如果集合不存在，MongoDB 会在您首次存储该集合的数据时创建该集合。
使用以下代码创建集合，例如:学生。
MongoCollection<Document> collection = database.getCollection("student");
创建文档
要使用 Java 驱动创建文档，请使用 document 类，并使用其append()方法将附加字段和值包含到文档对象中。例如，请参见下面的代码。
Document doc = new Document("name", "Ramesh");
doc.append("id",12);
插入文档
创建文档后，可以将文档插入到集合中。我们也可以插入单个和多个文档。要将单个文档插入集合，可以使用集合的insertOne()方法。
collection.insertOne(doc);
要添加多个文档，可以使用集合的 insertMany()方法，该方法需要插入一个文档列表。
获取文档
您可以使用集合的find()方法从文档中获取记录。find()方法返回一个 iterable，这样您就可以循环访问各个数据。
现在让我们将所有这些步骤放入一个 Java 应用中，并连接到 MongoDB 数据库。
Java MongoDB 示例:
这里我们通过指定主机和端口号连接到 mongodb，然后创建一个数据库和一个集合来存储数据。insertOne()方法用于在文档中插入一条记录。见下面的例子。
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
public class Demo {
public static void main(String[] args){
try{
// Connecting To MongoDB
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// Creating DataBase
MongoDatabase db = mongoClient.getDatabase("studytonight");
// Creating Collection/Table
MongoCollection<Document> table = db.getCollection("student");
// Creating Document/Record
Document doc = new Document("name", "Ramesh");
doc.append("id",12);
// Inserting Data
table.insertOne(doc);
}catch(Exception e){
System.out.println(e);
}
}
}
从 MongoDB 访问数据
创建数据库并插入数据后，现在让我们获取该记录。我们使用find()方法从文档中获取记录，然后迭代记录，并使用它们的名称进行显示。见下面的例子。
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
public class Demo {
public static void main(String[] args){
try{
// Connecting To MongoDB
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// Creating DataBase
MongoDatabase db = mongoClient.getDatabase("studytonight");
// Creating Collection/Table
MongoCollection<Document> table = db.getCollection("student");
// Accessing Data
FindIterable<Document> data = table.find();
// Traversing Data
for(Document record : data) {
System.out.println(record.getInteger("id")+" : "+record.getString("name"));
}
mongoClient.close();
}catch(Exception e){
System.out.println(e);
}
}
}
12:拉梅什
JSON 格式的访问
MongoDB 是一个基于文档的数据库，使用类似 JSON 的格式将数据存储到文档中。它提供了一种方法toJSON()将数据访问为我们在本例中使用的 JSON 格式。
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
public class Demo {
public static void main(String[] args){
try{
// Connecting To MongoDB
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// Creating DataBase
MongoDatabase db = mongoClient.getDatabase("studytonight");
// Creating Collection/Table
MongoCollection<Document> table = db.getCollection("student");
// Accessing Data
FindIterable<Document> data = table.find();
// Traversing Data
for(Document record : data) {
System.out.println(record.toJson());
}
mongoClient.close();
}catch(Exception e){
System.out.println(e);
}
}
}
{ " _ id ":{ " $ oid ":" 5 ECE 65 F5 和 8aa304abbf99953"}，"名称":" Ramesh "，" id": 12}
Java 杂项概念
Java RMI
远程方法调用(RMI)允许 java 对象在另一台机器上运行的对象上调用方法。RMI 提供 java 程序之间远程通信。RMI 用于构建分布式应用。
RMI 应用的概念
一个 RMI 应用可以分为两部分，客户端程序和服务器程序。一个服务器程序创建一些远程对象，使它们的引用可供客户端调用其上的方法。一个客户端程序请求服务器上的远程对象，并在其上调用方法。存根和骨架是用于与远程对象通信的两个重要对象。
烟蒂
在 RMI 中，存根是一个用作客户端网关的对象。所有传出的请求都是通过它发送的。当客户端调用存根对象上的方法时，会在内部执行以下操作:
- 使用远程虚拟机建立连接。
- 然后，它将参数传输到远程虚拟机。这也被称为法警
- 在第二步之后，它等待输出。
- 现在它读取作为输出的值或异常。
- 最后，它将值返回给客户端。
骨骼
在 RMI 中，骨架是用作服务器端网关的对象。所有传入的请求都是通过它发送的。当服务器调用骨架对象上的方法时，会在内部执行以下操作:
- 读取远程方法的所有参数。
- 在远程对象上调用方法。
- 然后，它写入并传输结果的参数。这也被称为法警。
存根和骨架
存根作为客户端程序的网关。它驻留在客户端，与骨骼对象通信。它建立远程对象之间的连接，并向其发送请求。
骨架对象驻留在服务器程序上。它负责将请求从存根传递到远程对象。
创建一个简单的 RMI 应用包括以下步骤
- 定义远程接口。
- 实现远程接口。
- 创建并启动远程应用
- 创建并启动客户端应用
定义远程接口
远程接口指定客户端可以远程调用的方法。客户端程序与远程接口通信，而不是与实现它的类通信。要成为远程接口，一个接口必须扩展 java.rmi 包的远程接口。
import java.rmi.*;
public interface AddServerInterface extends Remote
{
public int sum(int a,int b);
}
远程接口的实现
为了实现远程接口，一个类必须扩展 UnicastRemoteObject 或者使用 UnicastRemoteObject 类的 exportObject()方法。
import java.rmi.*;
import java.rmi.server.*;
public class Adder extends UnicastRemoteObject implements AddServerInterface
{
Adder()throws RemoteException{
super();
}
public int sum(int a,int b)
{
return a+b;
}
}
创建 AddServer 并托管 rmi 服务
您需要创建一个服务器应用，并在其中托管 rmi 服务加法器。这是使用 java.rmi .命名类的rebind()方法完成的。rebind()方法取两个参数，第一个参数代表对象引用的名称，第二个参数是引用实例加法器
import java.rmi.*;
import java.rmi.registry.*;
public class AddServer {
public static void main(String args[]) {
try {
AddServerInterface addService=new Adder();
Naming.rebind("AddService",addService); //addService object is hosted with name AddService
}
catch(Exception e) {
System.out.println(e);
}
}
}
创建客户端应用
客户端应用包含一个 java 程序，该程序调用命名类的lookup()方法。这个方法接受一个参数，即 rmi URL，并返回一个对类型为 AddServerInterface 的对象的引用。所有远程方法调用都是在这个对象上完成的。
import java.rmi.*;
public class Client {
public static void main(String args[]) {
try{
AddServerInterface st = (AddServerInterface)Naming.lookup("rmi://"+args[0]+"/AddService");
System.out.println(st.sum(25,8));
}
catch(Exception e) {
System.out.println(e);
}
}
}
运行这个 RMI 应用的步骤
将上述所有 java 文件保存到一个目录中，并将其命名为“rmi”
-
compile all the java files
javac *.java
-
Start RMI registry
start rmiregistry
-
Run Server file
java AddServer
-
Run Client file in another command prompt abd pass local host port number at run time
java Client 127.0.0.1
示例:
节目:Power.java
import java.rmi.*;
public interface Power extends Remote
{
public int power1()throwsRemoteException;
}
节目:PowerRemote.java
import java.rmi.*;
import java.rmi.server.*;
import java.util.Scanner;
public class PowerRemote extends UnicastRemoteObject implements Power
{
PowerRemote()throws RemoteException
{
super();
}
public int power1(int z)
{
int z;
Scanner sc = new Scanner(System.in);
System.out.println("Enter the base number ::");
int x = sc.nextInt();
System.out.println("Enter the exponent number ::");
int y = sc.nextInt();
z=y^x;
System.out.println(z);
}
}
MyServer.java
import java.rmi.*;
import java.rmi.registry.*;
public class MyServer
{
public static void main(String args[])
{
try
{
Power stub=new PowerRemote();
Naming.rebind("rmi://localhost:1995/shristee",stub);
}
catch(Exception e)
{
System.out.println(e);
}
}
}
MyClient.java
import java.rmi.*;
public class MyClient
{
public static void main(String args[])
{
try
{
Power stub=(Power)Naming.lookup("rmi://localhost:1995/shristee");
System.out.println(stub.power1());
}
catch(Exception e){}
}
}
Java 内部类
在 Java 中，内部类也称为嵌套类。内部类是嵌套类的一部分。当在嵌套类中定义非静态类时，它被称为内部类。它是在类或接口中定义的。内部类主要用于在一个地方对所有的类和接口进行逻辑分组，这使得代码更加易读和易于管理。内部类可以访问外部类的成员，包括所有私有数据成员和方法。
语法:
class OuterClass
{
//code
class InnerClass
{
//code
}
}
嵌套类的类型
- 非静态嵌套类
- 成员内部类
- 匿名内部类
- 本地内部类
- 本地内部类
以下是可以定义内部类的例子
1.带有静态方法的静态内部类
示例:
class outer
{
static class inner
{
public static void add(intx,int y)
{
int z = x + y;
System.out.println("add = " + z);
}
}
}
class innerclass_demo1
{
public static void main(String args[])
{
outer.inner.add(15,10);
}
}
2.使用非静态方法的静态内部类
示例:
class outer
{
static class inner
{
public void add(intx,int y)
{
int z = x + y;
System.out.println("add = " + z);
}
}
}
class innerclass_demo2
{
public static void main(String args[])
{
outer.innerob = new outer.inner();
ob.add(12,13);
}
}
3.具有非静态方法的非静态内部类
示例:
class outer
{
class inner
{
public void add(intx,int y)
{
int z = x + y;
System.out.println("add = " + z);
}
}
}
class innerclass_demo3
{
public static void main(String args[])
{
outer ot = new outer();
outer.inner in = ot.new inner();
in.add(34,56);
}
}
4.带有静态方法的非静态内部类
Note: it is an illegal combination. Only static variables are allowed and should be final.
示例:
class outer
{
class inner
{
/* Illegal combination */
/*public static void add(intx,int y)
{
int z = x + y;
System.out.println("add = " + z);
}*/
public static final int a = 45;
}
}
class innerclass_demo4
{
public static void main(String args[])
{
outer ot = new outer();
outer.inner in = ot.new inner();
System.out.println("Value of a = "+in.a);
}
}
5.局部方法中的嵌套内部类
示例:
class outer
{
public void display(intx,int y)
{
class inner
{
public void add(intx,int y)
{
int z = x + y;
System.out.println("add = " + z);
}
}
inner in = new inner();
in.add(x,y);
}
}
class innerclass_demo5
{
public static void main(String args[])
{
outer ob = new outer();
ob.display(23,56);
}
}
Java File类
在 Java 中，File 类用于表示文件或目录路径名。因为文件和目录的名称在不同的平台上有不同的格式。文件的路径可以是绝对的，也可以是相对的。有许多File类的方法可以用来创建、读取、删除或重命名文件。
此类扩展了对象类并实现了可序列化接口。下面是类的声明。
申报
public class File extends Object implements Serializable, Comparable<File>
File类位于 java.io 包中，所以我们需要导入包来使用它的功能。
以下是File类的字段。
| S.no | 田 | 描述 |
| one | 路径分隔符 | 它表示为字符串，用于分隔路径的字符。 |
| Two | pathSeparatorChar | 它用作路径分隔符。 |
| three | 分离器 | 它表示为字符串，用于分隔路径的字符。这是默认的名称分隔符。 |
| four | 分割器 | 它表示为字符串，用于分隔路径的字符。这是默认的名称分隔符。 |
以下是File类的构造器。
1.文件(文件父级，字符串子级)
2.文件(字符串路径名)
3.文件(字符串父项，字符串子项)
4. 选项卡
下面是File类的方法。
| 没有。 | 方法 | 描述 |
| one | createTempFile（字符串前缀，字符串后缀） | 它用于创建一个空文件。 |
| Two | createNewFile() | 它用于创建一个新文件，该文件为空并且具有抽象路径名。 |
| three | canWrite() | 它用于检查应用是否可以修改具有抽象路径的文件。 |
| four | canExecute() | 它用于检查应用是否可以执行具有抽象路径的文件。 |
| five | 可以读取（） | 它用于检查应用是否可以读取具有抽象路径的文件 |
| six | isAbsolute() | 用于检查抽象路径名是否为绝对路径名。 |
| seven | isDirectory() | 用于检查具有抽象路径名的文件是否为目录。 |
| eight | isFile（） | 用于检查具有抽象路径名的文件是否为文件。 |
| nine | getName（） | 它用于获取文件的名称。 |
| Ten | getparent() | 它用于获取父文件的名称 |
| Eleven | toPath() | 用于获取 java.nio.file.Path 的对象。 |
| Twelve | toURI() | 它用于创建具有抽象路径名的文件的网址。 |
| Thirteen | 列表文件() | 它用于获取抽象路径名的数组。 |
| Fourteen | getFressSpace() | 它用于获取未分配的字节数。 |
| Fifteen | 列表(文件名过滤器过滤器) | 它用于获取具有抽象路径名的文件名的字符串数组。 |
| Sixteen | mkdir() | 它用于创建目录名。 |
示例:创建文件
让我们通过创建一个新文件来开始使用文件。要创建一个文件，我们使用 createNewFile 方法，该方法以文件名作为参数。如果文件尚不存在，此方法将创建一个新文件。请看下面的例子。
import java.io.File;
import java.io.IOException;
public class FileCreateDemo1
{
public static void main(String[] args)
{
try
{
File Obj = new File("FileDemo.txt");
if (Obj.createNewFile()) {
System.out.println("******File created******");
System.out.println("Name of the file = " + Obj.getName());
}
else{
System.out.println("File already exists.");
}
}
catch (IOException e){
e.printStackTrace();
}
}
}
示例:写入文件
创建文件后，现在将数据写入文件。为了写入数据，使用了 Filewrite 类的方法。它将写入数据，但可能会引发异常，因此请确保也处理这些异常。
import java.io.FileWriter;
import java.io.IOException;
public class FileWriteDemo1
{
public static void main(String[] args)
{
try
{
FileWriterobj = new FileWriter("FileDemo.txt");
obj.write("Welcome to studytonight.com.");
obj.close();
System.out.println("File is Updated.");
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
示例:读取文件
为了从文件中读取数据，我们使用了File类和场景类来处理系统资源的输入和输出。这里我们使用两种方法hasNextLine()和nextLine()顺序读取数据。
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class FileReadDemo1
{
public static void main(String[] args)
{
try
{
File Obj = new File("FileDemo.txt");
Scanner obj1 = new Scanner(Obj);
while (obj1.hasNextLine())
{
String obj2 = obj1.nextLine();
System.out.println(obj2);
}
obj1.close();
}catch (FileNotFoundException e)
{
e.printStackTrace();
}
}
}
示例:复制文件
让我们再举一个例子，将一个文件的数据复制到另一个文件。这里我们使用文件输入和输出流来读写数据。虽然这只是将一个文件数据复制到另一个文件的过程，但是 Java 提供了内置的方法来将一个文件数据直接复制到另一个文件。见下面的例子。
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopyDemo1 {
public static void main(String[] args) {
FileInputStream a = null;
FileOutputStream b = null;
try {
File obj_in = new File("FileDemo.txt");
File obj_out = new File("FileDemo1.txt");
a = new FileInputStream(obj_in);
b = new FileOutputStream(obj_out);
byte[] buffer = new byte[1024];
int length;
while ((length = a.read(buffer)) > 0) {
b.write(buffer, 0, length);
}
a.close();
b.close();
System.out.println("File copied successfully!!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
文件权限
我们可以使用内置的方法检查权限，比如:文件的读、写、删除等。File类提供方法canRead()、canWrite()等检查操作是否允许。
import java.io.*;
public class FilePermissionDemo1 {
public static void main(String[] args) {
File a = new File("FileDemo1.txt");
boolean b = a.exists();
if (b == true) {
System.out.println("Executable: " + a.canExecute());
System.out.println("Readable: " + a.canRead());
System.out.println("Writable: " + a.canWrite());
} else {
System.out.println("File not found.");
}
}
}
正在检索文件信息
这是文件处理的一个重要部分，获取文件的元数据是保存文件信息所必需的，如:File类型、文件位置、文件权限等。在这个例子中，我们使用了 File 类的一些内置方法来获取关于文件的信息。见下面的例子
import java.io.File;
public class FileInfoDemo1
{
public static void main(String[] args)
{
File Obj = new File("FileDemo1.txt");
if (Obj.exists())
{
System.out.println("File name= " + Obj.getName());
System.out.println("***********************************");
System.out.println("Absolute path= " + Obj.getAbsolutePath());
System.out.println("***********************************");
System.out.println("Writeable= " + Obj.canWrite());
System.out.println("***********************************");
System.out.println("Readable= " + Obj.canRead());
System.out.println("***********************************");
System.out.println("File size in bytes= " + Obj.length());
}
else
{
System.out.println("file does not exist.");
}
}
}
删除文件
在这种情况下，我们需要删除一个文件，然后 Java 提供了方法delete()来帮助使用代码删除一个文件。在这个例子中，我们正在删除文件。方法返回一个布尔值，以确保文件已成功删除。
import java.io.File;
public class FileDeleteDemo1 {
public static void main(String[] args) {
File Obj = new File("FileDemo.txt");
if (Obj.delete()) {
System.out.println(Obj.getName() + " has been deleted");
} else {
System.out.println("Failed");
}
}
}
Java 中的AbstractList
在 Java 中，AbstractList是 Java 集合框架的一部分。AbstractList由集合接口和抽象集合类实现。当列表无法修改时使用。为了实现这个AbstractList，类与 get()和 size()方法一起使用。
下面是班级层级
语法:
public abstract class AbstractList<E> extends AbstractCollection<E>implements List<E>
下面是AbstractList类的方法
| 没有。 | 方法 | 描述 |
| one | 添加(英、法) | 它用于将元素添加到列表的末尾。 |
| Two | 加法(整数索引，E 元素) | 它用于在列表的指定位置添加元素。 |
| three | 加法(整数索引，集合 c) | 它用于将指定集合中的元素添加到指定位置。 |
| four | 清除() | 它用于从列表中移除所有元素。 |
| five | 等于(对象 0) | 它用于比较列表中另一个元素的元素。 |
| six | get(int 索引) | 它用于从列表中的指定位置获取元素。 |
| seven | hashCode() | 它用于从列表中获取哈希代码。 |
| eight | 索引（对象 o） | 它用于从列表中获取第一个元素。如果列表为空，则返回-1。 |
| nine | 迭代器() | 它返回列表中的所有元素。使用迭代器。 |
| Ten | lastIndexOf（Object o） | 它用于从列表中获取最后一个元素。如果列表为空，则返回-1。 |
| Eleven | 列表迭代器() | 它用于以适当的顺序获取迭代列表。 |
| Twelve | 移除(整数索引) | 它用于从列表中移除指定的元素。 |
| Thirteen | removeRange(intfromIndex，inttoIndex) | 它用于从指定范围中移除元素。 |
| Fourteen | 集合(整数索引，E 元素) | 它用于替换指定元素中的元素。 |
| Fifteen | subList（intfromIndex， inttoIndex） | 它用于获取指定范围内的元素。 |
示例:
import java.util.*;
public class AbstractListDemo1 {
public static void main(String args[])
{
AbstractList <string>list = new LinkedList<string>();
list.add("Dog");
list.add("Cat");
list.add("Bird");
list.add("Tiger");
list.add("Rabit");
System.out.println("***********************************");
System.out.println("Elements in the List 1:" + list);
list.add(3, "Deer");
System.out.println("***********************************************************");
System.out.println("After Adding Deer at position 3");
System.out.println("Elements in the List 1:" + list); //New List
System.out.println("***********************************************************");
AbstractList <string>list1 = new LinkedList<string>();
list1.add("Dog");
list1.add("Cat");
list1.add("Bird");
list1.add("Tiger");
list1.add("Rabit");
System.out.println("***********************************************************");
System.out.println("Elements in the List 2 :" + list1); //New List2
System.out.println("***********************************************************");
boolean ab = list.equals(list1);
System.out.println("Are both list equal : "+ ab);
System.out.println("***********************************************************");
String bc = list1.get(3);
System.out.println("Get element of index 3 : "+bc);
System.out.println("***********************************************************");
int cd= list.hashCode();
System.out.println("HashCode : " + cd);
System.out.println("***********************************************************");
int de= list.indexOf("Bird");
System.out.println("index of Bird in List 1: " + de);
System.out.println("***********************************************************");
Iterator ef = list.iterator();
while (ef.hasNext())
{
System.out.println("Element : "+ ef.next());
}
System.out.println("***********************************************************");
intfg= list.lastIndexOf("Rabit");
System.out.println("Last index of Rabit : "+ fg);
System.out.println("***********************************************************");
ListIteratorgh = list.listIterator(3);
System.out.println("The list is as follows:");
while (gh.hasNext()) {
System.out.println(gh.next());
}
System.out.println("***********************************************************");
}
}</string></string></string></string>
不可变列表
在 Java 中，不可变列表是不可变的。不可变列表的元素是固定的。这意味着列表的元素是只读的。如果我们试图添加、删除或更新任何元素，那么它将抛出 UnsupportedOperationException。它也不允许空元素。如果我们试图创建一个空元素，那么它将抛出 NullPointerException，如果我们试图添加空元素，那么它将抛出 UnsupportedOperationException。
以下是不变列表的优势。
1.它是螺纹安全的。
2.记忆组织得很好。
下面是类层次结构
Java AbstractSequentialList
原文：https://www.studytonight.com/java/abstract-sequential-list.php
在 Java 中，抽象序列列表类是 Java 集合框架的一部分。AbstractSequentialList由集合接口和抽象集合类实现。当列表无法修改时使用。为了实现这个AbstractList类，使用了 get() 和 size() 方法。
下面是类层次结构
语法:
public abstract class AbstractSequentialList<E>extends AbstractList<E>
下面是抽象序列列表类的方法
| 没有。 | 方法 | 描述 |
| one | 加法(整数索引，E 元素) | 它用于在列表的指定位置添加元素。 |
| Two | 整数索引，集合 c | 它用于在列表的指定位置的指定集合中添加元素。 |
| three | get(int 索引) | 它用于从列表中的指定位置获取元素。 |
| four | 迭代器() | 它返回列表中的所有元素。使用迭代器。 |
| five | 列表迭代器() | 它用于以适当的顺序获取迭代列表。 |
| six | 移除(整数索引) | 它用于从列表中移除指定的元素。 |
| seven | 集合(整数索引，E 元素) | 它用于替换指定元素中的元素。 |
示例:
import java.util.*;
public class AbstractSequentialListDemo1 {
public static void main(String[] args)
{
AbstractSequentialList<Integer> a = new LinkedList<>();
a.add(1);
a.add(2);
a.add(3);
a.add(4);
a.add(5);
a.add(6);
System.out.println("List = "+a);
System.out.println("************************************");
System.out.println("The 2nd elements in the List is: "+ a.get(2));
System.out.println("************************************");
System.out.println("Remove 3rd element from the list: "+a.remove(3));
System.out.println("************************************");
System.out.println("List = "+a);
}
}
Java CopyOnWriteArrayList
原文：https://www.studytonight.com/java/copy-on-write-array-list.php
在 Java 中，JDK 1.5 引入了 CopyOnWriteArrayList 类。这个类实现了列表接口。这是ArrayList的修改版本。这非常昂贵，因为每次执行更新时都会创建一个克隆拷贝。它是螺纹安全的。在此类中，无法执行删除操作，如果执行，将出现不支持操作异常错误。
下面是 CopyOnWriteArrayListClass 的方法
| 没有。 | 方法 | 描述 |
| one | 添加(英、法) | 它用于将元素添加到列表的末尾。 |
| Two | 加法(整数索引，E 元素) | 它用于在列表的指定位置添加元素。 |
| three | 加法(整数索引，集合 c) | 它用于在列表的指定位置的指定集合中添加元素。 |
| four | 清除() | 它用于从列表中移除所有元素。 |
| five | 等于(对象 0) | 它用于比较列表中另一个元素的元素。 |
| six | get(int 索引) | 它用于从列表中的指定位置获取元素。 |
| seven | hashCode() | 它用于从列表中获取哈希代码。 |
| eight | 索引（对象 o） | 它用于从列表中获取第一个元素。如果列表为空，则返回-1。 |
| nine | 迭代器() | 它返回列表中的所有元素。使用迭代器。 |
| Ten | lastIndexOf（Object o） | 它用于从列表中获取最后一个元素。如果列表为空，则返回-1。 |
| Eleven | 列表迭代器() | 它用于以适当的顺序获取迭代列表。 |
| Twelve | 移除(整数索引) | 它用于从列表中移除指定的元素。 |
| Thirteen | removeRange(intfromIndex，inttoIndex) | 它用于从指定范围中移除元素。 |
| Fourteen | 集合(整数索引，E 元素) | 它用于替换指定元素中的元素。 |
| Fifteen | subList（intfromIndex， inttoIndex） | 它用于获取指定范围内的元素。 |
| Sixteen | toaarray(t[]a) | 它用于以适当的顺序获取列表中的所有元素。 |
| Seventeen | toString() | 它用于获取列表的字符串表示形式 |
示例:
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.*;
class CopyOnWriteArrayListDemo1 extends Thread {
static CopyOnWriteArrayListobj = new CopyOnWriteArrayList();
public void run()
{
obj.add("Green");
}
public static void main(String[] args) throws InterruptedException
{
obj.add("Red");
obj.add("Blue");
obj.add("Pink");
CopyOnWriteArrayListDemo1 obj1 = new CopyOnWriteArrayListDemo1 ();
obj1.run();
Thread.sleep(1000);
Iterator a = obj.iterator();
while (a.hasNext())
{
String s = (String)a.next();
System.out.println(s);
Thread.sleep(1000);
}
System.out.println(obj);
}
}
Java AbstractSet
在 Java 中，AbstractSet类是 Java 集合框架的一部分。AbstractList由集合接口和抽象集合类实现。抽象集合类不覆盖抽象集合类，但是可以实现equals()和hashCode()方法。
下面是班级层级
语法:
public abstract class AbstractSet<E> extends AbstractCollection<E>implements Set<E>
示例:
import java.util.*;
public class AbstractSetDemo1{
public static void main(String[] args) throws Exception
{
try {
AbstractSet<string>obj = new TreeSet<string>();
obj.add("Red");
obj.add("Green");
obj.add("Blue");
obj.add("Black");
obj.add("Orange");
System.out.println("AbstractSet: "+ obj);
}
catch (Exception e)
{
System.out.println(e);
}
}
}</string></string>
| 没有。 | 方法 | 描述 |
| one | 添加(英、法) | 它用于将元素添加到集合的末尾。 |
| Two | 清除() | 它用于从集合中移除所有元素。 |
| three | 等于(对象 0) | 它用于比较集合中另一个元素的元素。 |
| four | hashCode() | 它用于从集合中获取哈希代码。 |
| five | 迭代器() | 它返回集合中的所有元素。使用迭代器。 |
| six | 列表迭代器() | 它用于以适当的顺序获得迭代集。 |
| seven | 移除(整数索引) | 它用于从集合中移除指定的元素。 |
示例:
import java.util.*;
public class AbstractSetDemo2 {
public static void main(String args[])
{
AbstractSet<String> set = new TreeSet<String>();
set.add("Dog");
set.add("Cat");
set.add("Bird");
set.add("Tiger");
set.add("Rabit");
System.out.println("***********************************");
System.out.println("Elements in the set 1:" + set);
AbstractSet<String> set1 = new TreeSet<String>();
set1.add("Dog");
set1.add("Cat");
set1.add("Bird");
set1.add("Tiger");
set1.add("Rabit");
System.out.println("***********************************************************");
System.out.println("Elements in the Set 2 :" + set1);
System.out.println("***********************************************************");
boolean a = set.equals(set1);
System.out.println("Are both set equal : "+ a);
System.out.println("***********************************************************");
int c= set.hashCode();
System.out.println("HashCode : " + c);
System.out.println("***********************************************************");
Iterator e = set.iterator();
while (e.hasNext())
{
System.out.println("Element : "+ e.next());
}
System.out.println("***********************************************************");
}
}
EnumSet
在 Java 中，EnumSet 扩展了抽象集，并在 Set 接口中实现。这个类是 Java 集合框架的成员，也不能同步。EnumDet 比 HashSet 快。
语法:
public abstract class EnumSet<E extends Enum<E>>
下面是枚举类的方法
| 没有。 | 方法 | 描述 |
| one | (e1)的枚举 | 它用于使用指定的元素创建EnumSet。 |
| Two | enumset complete of(enumset s) | 它用于使用唯一的指定元素创建EnumSet。 |
| three | enumsetallof(类元素类型) | 它用于使用类的所有元素创建EnumSet。 |
| four | 枚举范围(从，到) | 它用于获取给定范围的枚举元素。 |
| five | EnumSetcopyof() | 它用于将集合中的元素复制到新的EnumSet中。 |
示例:
import java.util.EnumSet;
enum Demo1
{
RED, BLACK, BLUE, PINK, WHITE
};
public class EnumDemo1
{
public static void main(String[] args)
{
EnumSet1<Demo1> a1, a2, a3, a4;
a1 = EnumSet1.of(Demo1.RED, Demo1.BLACK, Demo1.BLUE, Demo1.PINK, Demo1.WHITE);
a2 = EnumSet1.complementOf(a1);
a3 = EnumSet1.allOf(Demo1.class);
a4 = EnumSet1.range(Demo1.RED, Demo1.PINK);
System.out.println("a 1: " + a1);
System.out.println("a 2: " + a2);
System.out.println("a 3: " + a3);
System.out.println("a 4: " + a4);
}
}
Java IdentityHashMap类
在 Java 中，IdentityHashMap 类实现了 Map 接口。它还实现了可序列化和可克隆的接口。它扩展了抽象映射类。它需要通过引用进行比较的对象。
以下是 IdentityHashMap 类的构造器
1.IdentityHashMap()。
2.IdentityHashMap(IntexpectedMaxsize)
3.IdentityHashMap(Map m)
下面是AbstractList类的方法
| 没有。 | 方法 | 描述 |
| one | 清除() | 它用于从映射中移除所有映射。 |
| Two | 克隆() | 它用于获取映射的副本。 |
| three | 包含密钥(对象密钥) | 它用于获取指定键的映射。 |
| four | 包含键(对象值) | 它用于获取指定值的映射。 |
| five | entrySet() | 它用于设置映射视图。 |
| six | 等于(对象 0) | 它用于比较映射中另一个对象的对象。 |
| seven | 获取(对象键) | 它用于从映射中的指定位置获取值。 |
| eight | hashCode() | 它用于从映射中获取哈希代码。 |
| nine | hashCode() | 它用于从映射中获取哈希代码。 |
| nine | isEmpty() | 它用于检查映射是否包含任何键值。 |
| Ten | 密钥集() | 它用于在映射中设置视图。 |
| Eleven | 放(K 键，V 值)。 | 它用于在映射中添加关键字和值。 |
| Twelve | 映射(米) | 它用于复制整个映射。 |
| Thirteen | 移除(对象键) | 它用于从弱HashMap中移除密钥。 |
| Fourteen | 大小() | 它用于获取映射中键值的总数。 |
| Fifteen | 值() | 它用于从映射中获取值。 |
示例:
import java.util.Map;
import java.util.HashMap;
import java.util.IdentityHashMap;
public class IdentityHashMapDemo1
{
public static void main(String[] args)
{
Map a = new HashMap();
Map b = new IdentityHashMap();
a.put("H_key","H_value");
a.put(new String("H_key"),"H_value1");
b.put("H_key","H_value");
b.put(new String("H_key"),"H_value1");
System.out.println("HashMapSize : "+a.size());
System.out.println("IdentityHashMapSize : "+b.size());
}
}
不可变映射
在 Java 中，不可变映射是一种映射。它是不可变的意味着它不能被修改，它在声明后是固定的。如果试图添加、删除或更新元素，则会引发 UnsupportedOperationException。它也不允许任何空元素。
以下是不变列表的优势。
1.它是螺纹安全的。
2.记忆组织得很好。
下面是班级层级
Java SortedMap接口
原文：https://www.studytonight.com/java/sorted-map-interface.php
在 Java 中，SortedMap 是 Collection 框架的一个接口。SortedMap 扩展了 Map 接口，还提供了元素的排序。遍历排序后的元素变得更加容易。
以下是 SortedMap 接口的方法。
| 没有。 | 方法 | 描述 |
| one | 子密钥 | 它用于查看给定范围内的元素 |
| Two | 校长 | 它用于获取小于 toKey 的密钥。 |
| three | 大小映射(K fromKey) | 它用于获取大于或等于 fromKey 的密钥。 |
| four | firstKey() | 它用于获取最低键。 |
| five | lastKey() | 它用于获取最高密钥。 |
| six | Comparator() | 它用于获取映射中使用的Comparator。 |
| seven | 值() | 它用于获取映射的值 |
| eight | 密钥集() | 它用于从映射中获取集合视图。 |
| nine | entrySet() | 它用于获取映射中包含的映射的集合视图。 |
示例:
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
public class SortedMapDemo1
{
public static void main(String[] args)
{
SortedMap<Integer, String> a = new TreeMap<Integer, String>();
a.put(new Integer(2), "Red");
a.put(new Integer(3), "Pink");
a.put(new Integer(5), "Yellow");
a.put(new Integer(4), "Black");
a.put(new Integer(1), "Green");
Set b = a.entrySet();
Iterator i = b.iterator();
while (i.hasNext())
{
Map.Entry c = (Map.Entry)i.next();
int key1 = (Integer)c.getKey();
String value1 = (String)c.getValue();
System.out.println("Key : " + key1 + " || value : " + value1);
}
}
}
Queue接口
在 Java 中，Queue 接口在 java.util 包下。队列扩展了集合接口。它用于保存集合中要处理的元素，还可以执行插入、删除等操作。在这个界面中，元素被插入到列表的末尾，并从列表的开头删除。它遵循先进先出的概念，即先进先出。要声明队列，需要一个具体的类，通常使用优先级队列和LinkedList类。
下面是 Queue 接口的方法。
| 没有。 | 方法 | 描述 |
| one | 添加() | 它用于在队列中添加元素。 |
| Two | peek() | 它用来查看队列的头.. |
| three | 元素() | 用于检查队列是否为空。如果为空，它将抛出 NoSuchElementFound。 |
| four | 移除() | 它用于从队列头移除元素。 |
| five | 民意测验() | 它用于移除元素并返回队列头。 |
| six | 大小() | 它用于获取元素的大小。 |
示例:
import java.util.LinkedList;
import java.util.Queue;
public class QueueDemo1
{
public static void main(String[] args)
{
Queue<Integer> a = new LinkedList<>();
for (int i=0; i<10; i++)
a.add(i);
System.out.println("**************************************");
System.out.println("Elements of Queue : "+a);
System.out.println("**************************************");
int b= a.remove();
System.out.println("Removed element from the Queue : " + b);
System.out.println(a);
System.out.println("**************************************");
int c = a.peek();
System.out.println("head of queue-" + c);
System.out.println("**************************************");
int d= a.size();
System.out.println("Size of queue-" + d);
}
}
Deque接口
在 Java 中，Deque 接口在 Java . util . Dequee 下，是 java.util.Queue 接口的一个子类型。Deque 是一个双端队列，这意味着可以从两端添加和删除元素。德格可以用作队列或栈，即先进先出或后进先出。
下图是德客界面的层次结构
以下是德客界面的方法
| 没有。 | 方法 | 描述 |
| one | 添加(元素) | 它用于在德格的尾部添加元素。 |
| Two | 添加第一个(元素) | 它用于在德格的头部添加元素。 |
| three | addLast（item） | 它用于在德格的尾部添加元素。 |
| four | 报价(要素) | 它用于在尾部添加一个元素，如果添加成功，将返回一个布尔值。 |
| five | offerFirst(元素) | 它用于在头部添加元素，如果添加成功，则返回布尔值。 |
| six | offerLast(元素) | 它用于在尾部添加一个元素，如果添加成功，将返回一个布尔值。 |
| seven | 迭代器() | 它是用来迭代的。 |
| eight | 下降畸胎() | 它用于在 deque 中以相反的顺序进行迭代。 |
| nine | 推动(元件) | 它用于在文件头添加元素。 |
| Ten | 流行元素 | 它是用来去除头部的元素。 |
| Eleven | removeFirst() | 它是用来去除头部的元素。 |
| Twelve | removeLast() | 它用于从 deque 的尾部移除元素 |
| Thirteen | 民意测验() | 它用于获取和移除 deque 中的第一个元素。如果 deque 为空，则返回 null。 |
| Fourteen | pollFirst() | 它用于获取和移除 deque 中的第一个元素。如果 deque 为空，则返回 null。 |
| Fifteen | pollLast() | 它用于获取和移除 deque 中的最后一个元素。如果 deque 为空，则返回 null。 |
| Sixteen | peek() | 它是用来去除鱼头的。 |
| Seventeen | peekFirst() | 它是用来去除鱼头的。 |
| Eighteen | 扫视最后（） | 它是用来去除尾巴的。 |
示例:
import java.util.*;
public class DequeDemo1
{
public static void main(String[] args)
{
Deque<string>obj = new LinkedList<string>();
obj.add("A 1 (Tail)");
obj.addFirst("B 2 (Head)");
obj.addLast("C 3 (Tail)");
obj.push("D 4 (Head)");
obj.offer("E 5 (Tail)");
obj.offerFirst("F 6 (Head)");
obj.offerLast("G 7 (Tail)");
System.out.println("*****************************************************************************");
System.out.println(obj + "\n");
System.out.println("*****************************************************************************");
System.out.println("Standard Iterator");
Iterator iterator = obj.iterator();
while (iterator.hasNext())
System.out.println("\t" + iterator.next());
Iterator reverse = obj.descendingIterator();
System.out.println("*****************************************************************************");
System.out.println("Reverse Iterator");
while (reverse.hasNext())
System.out.println("\t" + reverse.next());
System.out.println("*****************************************************************************");
System.out.println("Peek " + obj.peek());
System.out.println("*****************************************************************************");
System.out.println("After peek: " + obj);
System.out.println("*****************************************************************************");
System.out.println("Pop " + obj.pop());
System.out.println("*****************************************************************************");
System.out.println("After pop: " + obj);
System.out.println("*****************************************************************************");
System.out.println("Contains element 3: " + obj.contains("Element 3 (Tail)"));
obj.removeFirst();
obj.removeLast();
System.out.println("*****************************************************************************");
System.out.println("Deque after removing " + "first and last: " + obj);
}
}</string></string>
布局管理器
在 Java 中，布局管理器用于按顺序排列组件。LayoutMananger 是一个实现布局管理器类的接口。
下面是一些用于布局管理器表示的类。
1. java.awt.BorderLayout
2. java.awt.FlowLayout
3.java.awt.GridLayout
4.java.awt.CardLayout
5.javax . swing . box layout-javax . swing . box 配置图
边框布局
当我们想要在五个区域中排列组件时，使用了边框布局。这五个地区可以是北部、南部、东部、西部和中部。边框布局中有 5 种类型的构造器。它们如下:
1.公共静态最终 int NORTH
2.南方公共静态决赛
3.公共静态最终 int EAST
4.西部公共静态决赛
5.公共静态最终国际中心
示例:
import java.awt.*;
import javax.swing.*;
public class BorderDemo1
{
JFrame frame;
BorderDemo1()
{
frame=new JFrame();
JButton box1=new JButton("**NORTH**");;
JButton box2=new JButton("**SOUTH**");;
JButton box3=new JButton("**EAST**");;
JButton box4=new JButton("**WEST**");;
JButton box5=new JButton("**CENTER**");;
frame.add(box1,BorderLayout.NORTH);
frame.add(box2,BorderLayout.SOUTH);
frame.add(box3,BorderLayout.EAST);
frame.add(box4,BorderLayout.WEST);
frame.add(box5,BorderLayout.CENTER);
frame.setSize(400,400);
frame.setVisible(true);
}
public static void main(String[] args)
{
new BorderDemo1();
}
}
网格布局
当我们想要在矩形网格中排列组件时，使用网格布局。
网格布局中有 3 种类型的构造器。它们如下:
1.网格布局()
2.网格布局(整数行，整数列)
3.网格布局(int 行，int 列，in gap，int vgap)
示例:
import java.awt.*;
import javax.swing.*;
public class GridDemo1{
JFrame frame1;
GridDemo1(){
frame1=new JFrame();
JButton box1=new JButton("*1*");
JButton box2=new JButton("*2*");
JButton box3=new JButton("*3*");
JButton box4=new JButton("*4*");
JButton box5=new JButton("*5*");
JButton box6=new JButton("*6*");
JButton box7=new JButton("*7*");
JButton box8=new JButton("*8*");
JButton box9=new JButton("*9*");
frame1.add(box1);
frame1.add(box2);
frame1.add(box3);
frame1.add(box4);
frame1.add(box5);
frame1.add(box6);
frame1.add(box7);
frame1.add(box8);
frame1.add(box9);
frame1.setLayout(new GridLayout(3,3));
frame1.setSize(500,500);
frame1.setVisible(true);
}
public static void main(String[] args) {
new GridDemo1();
}
}
流程布局
当我们想要一个接一个地按顺序排列组件时，使用了“流布局”。
流布局中有 3 种类型的构造器。它们如下:
1.FlowLayout()
2.内部对齐(int align)
3.流布局(int align，in gap，intvgap)
示例:
import java.awt.*;
import javax.swing.*;
public class FlowDemo1{
JFrame frame1;
FlowDemo1(){
frame1=new JFrame();
JButton box1=new JButton("1");
JButton box2=new JButton("2");
JButton box3=new JButton("3");
JButton box4=new JButton("4");
JButton box5=new JButton("5");
JButton box6=new JButton("6");
JButton box7=new JButton("7");
JButton box8=new JButton("8");
JButton box9=new JButton("9");
JButton box10=new JButton("10");
frame1.add(box1);
frame1.add(box2);
frame1.add(box3);
frame1.add(box4);
frame1.add(box5);
frame1.add(box6);
frame1.add(box7);
frame1.add(box8);
frame1.add(box9);
frame1.add(box10);
frame1.setLayout(new FlowLayout(FlowLayout.LEFT));
frame1.setSize(400,400);
frame1.setVisible(true);
}
public static void main(String[] args) {
new FlowDemo1();
}
}
箱体布局
当我们想要垂直或水平排列组件时，使用方框布局。
盒子布局是盒子布局中唯一的构造器
示例:
import java.awt.*;
import javax.swing.*;
public class BoxDemo1 extends Frame {
Button buttonBox[];
public BoxDemo1 ()
{
buttonBox = new Button [2];
for (inti = 0;i<2;i++)
{
buttonBox[i] = new Button ("** Button " + (i + 1)+" **");
add (buttonBox[i]);
}
setLayout (new BoxLayout (this, BoxLayout.Y_AXIS));
setSize(500,500);
setVisible(true);
}
public static void main(String args[])
{
BoxDemo1 obj=new BoxDemo1();
}
}
示例:
import java.awt.*;
import javax.swing.*;
public class BoxDemo1 extends Frame {
Button buttonBox[];
public BoxDemo1 ()
{
buttonBox = new Button [2];
for (inti = 0;i<2;i++)
{
buttonBox[i] = new Button ("** Button " + (i + 1)+" **");
add (buttonBox[i]);
}
setLayout (new BoxLayout (this, BoxLayout.X_AXIS));
setSize(500,500);
setVisible(true);
}
public static void main(String args[])
{
BoxDemo1 obj=new BoxDemo1();
}
}
卡片布局
当我们希望一次只看到一个组件时，使用“卡片布局”。
卡片布局中有两种类型的构造器。它们如下:
1.CardLayout()
2.卡片布局
示例:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class CardDemo1 extends JFrame implements ActionListener
{
CardLayoutc_Card;
JButton box1,box2,box3;
Container d;
CardDemo1()
{
d=getContentPane();
c_Card=new CardLayout(40,30);
d.setLayout(c_Card);
box1=new JButton("studytonight_1");
box2=new JButton("studytonight_2");
box3=new JButton("studytonight_3");
box1.addActionListener(this);
box2.addActionListener(this);
box3.addActionListener(this);
d.add("P",box1);
d.add("Q",box2);
d.add("R",box3);
}
public void actionPerformed(ActionEvent e)
{
c_Card.next(d);
}
public static void main(String[] args)
{
CardDemo1 obj =new CardDemo1();
obj.setSize(500,500);
obj.setVisible(true);
obj.setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
Java 程序
数组程序
Java 程序：显示下三角矩阵
原文：https://www.studytonight.com/java-programs/java-program-to-display-lower-triangular-matrix
在本教程中，我们将学习如何显示下三角矩阵。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
下面是同样的图示。
输入:输入矩阵元素:
1 2 3
4 5 6
7 8 9
输出:下三角矩阵为:
1 0 0
4 5 0
7 8 9
上述情况有两种情况:
情况 1:当值由用户定义时
情况 2:当值被预定义时
让我们分别看一下这些案例。
程序 1:显示下三角矩阵
在下面的程序中，我们将看到当值由用户定义时，如何显示下三角矩阵。
算法:
- 开始
- 声明变量来存储行数和列数。
- 要求用户初始化行和列。
- 检查行数和列数是否相等。
- 如果不相等，则显示一条消息，说明行数和列数应该相等。
- 如果相等，则声明一个矩阵。
- 要求用户初始化矩阵元素。
- 打印原始矩阵。
- 调用一个方法来显示下三角矩阵。
- 使用循环迭代元素。
- 将 0 分配给行数小于列数的元素。
- 打印结果矩阵。
- 停下来。
下面是相同的代码。
// Java Program to print the lower triangular matrix
import java.util.*;
public class Main
{
// Print the matrix
public static void printMatrix(int[][] arr)
{
int m = arr.length; //For Rows
int n = arr[0].length; //For columns
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
//Display the lower triangular matrix
public static void lowerTriangularMatrix(int arr[][])
{
int m = arr.length;
int n = arr[0].length;
if (m != n)
{
System.out.println("Matrix entered should be a Square Matrix");
System.out.println("Try Again..");
return;
}
else
{
// looping over the whole matrix
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i < j)
{
arr[i][j] = 0;
}
}
}
System.out.println( "Lower Triangular Matrix is : ");
// printing the lower triangular matrix
printMatrix(arr);
}
}
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
int m,n; //Declare variables for rows and columns
System.out.println("Enter the number of rows: ");
m=sc.nextInt();
System.out.println("Enter the number of columns: ");
n=sc.nextInt();
System.out.println("Enter the Matrix Elements: ");
int arr[][] = new int[m][n]; //Declare the matrix
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
arr[i][j]=sc.nextInt(); //Initialize the matrix
}
}
//Print Original Matrix
System.out.println( "Original Matrix is : ");
printMatrix(arr);
// calling to display the lower triangular matrix
lowerTriangularMatrix(arr);
}
}
输入行数:3
输入列数:3
输入矩阵元素:1 2 8 7 5 4 3 9
原始矩阵为:
1 2 8
7 6 5
4 3 9
下三角矩阵为:
1 0 0
7 6 0
4 3 9
程序 2:显示下三角矩阵
在下面的程序中，我们将看到如何显示预定义值时的下三角矩阵。
算法:
- 开始
- 声明变量来存储行数和列数。
- 初始化行和列。
- 检查行数和列数是否相等。
- 如果不相等，则显示一条消息，说明行数和列数应该相等。
- 如果相等，则声明一个矩阵。
- 初始化矩阵元素。
- 打印原始矩阵。
- 调用一个方法来显示下三角矩阵。
- 使用循环迭代元素。
- 将 0 分配给行数小于列数的元素。
- 打印结果矩阵。
- 停下来。
下面是相同的代码。
// Java Program to print the lower triangular matrix
import java.io.*;
public class Main
{
// Print the matrix
public static void printMatrix(int[][] arr)
{
int m = arr.length; //For Rows
int n = arr[0].length; //For columns
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
//Display the lower triangular matrix
public static void lowerTriangularMatrix(int arr[][])
{
int m = arr.length;
int n = arr[0].length;
if (m != n)
{
System.out.println("Matrix entered should be a Square Matrix");
System.out.println("Try Again..");
return;
}
else
{
// looping over the whole matrix
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i < j)
{
arr[i][j] = 0;
}
}
}
System.out.println( "Lower Triangular Matrix is : ");
// printing the lower triangular matrix
printMatrix(arr);
}
}
public static void main(String[] args)
{
int arr[][] = { { 8, 7, 6 }, { 4, 2, 5 }, { 7, 9, 8 } };
//Print Original Matrix
System.out.println( "Original Matrix is : ");
printMatrix(arr);
// calling to display the lower triangular matrix
lowerTriangularMatrix(arr);
}
}
原始矩阵为:
8 7 6
4 2 5
7 9 8
下三角矩阵为:
8 0 0
4 2 0
7 9 8
Java 程序：在数组中输入元素时检查数组边界
在本教程中，我们将学习如何在向数组中输入元素时检查数组边界。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:
输入数组大小:5
输入数组元素:4 6 2 3 7 8
输出:超出数组界限...
程序 1:在数组中输入元素时检查数组边界
在这种方法中，我们将看到如何在使用 try catch 块输入数组元素时检查数组边界。使用这种方法背后的逻辑是，首先我们声明一个大小为 n 的数组。然后，我们要求用户给出输入。这里，我们使用一个 try 块进行输入。但是我们要求用户给出的输入大于数组的大小，也就是说，我们要求用户输入 n+1 个元素。因为我们已经声明了大小为 n 的数组，但是我们给出了 n+1 个元素作为输入，所以抛出了 ArrayIndexOutOfBoundsException。这个异常现在由 catch 块处理。因此，用户现在将获得一个输出，声明的元素数量大于数组大小。所以再试一次。
算法
- 开始吧。
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 采取试捕块。
- 在尝试块中，要求用户初始化数组元素。
- 输入大于指定大小的元素。
- 这将引发 ArrayIndexOutOfBoundsException。
- 现在捕获块将打印消息“超出数组界限”...再试一次。
- 停止
下面是相同的代码。
下面的程序演示了如何在使用 Try Catch Block 向数组中输入元素时检查数组边界。
/*Java Program to Check Array Bounds while Inputing elements into an Array*/
import java.util.*;
public class Main
{
// Main driver method
public static void main(String args[])
throws ArrayIndexOutOfBoundsException
{
// Taking input from user
Scanner sc = new Scanner(System.in);
//Ask the user to enter the Array Size
int n;
System.out.println("Enter the Array Size ");
n=sc.nextInt();
// Storing user input elements in an array
int arr[] = new int[n];
System.out.println("Enter more number of elements than the mentioned size ");
// Try block to check exception
try {
// Forcefully iteration loop no of times
for (int i = 0; i <= n; i++)
{
arr[i] = sc.nextInt();
}
}
catch (ArrayIndexOutOfBoundsException e)
{
// Print message when any exception occurs
System.out.println("Array Bounds Exceeded...");
System.out.println("Try Again");
}
}
}
输入数组大小 3
输入比所述大小更多的元素数量
3 5 2 1
超出数组界限...
再试一次
程序 2:在数组中输入元素时检查数组边界
在这种方法中，我们将使用 while 循环来限制输入的数量。这是在接受用户输入时检查数组边界的最简单方法。使用这种方法背后的逻辑是，我们使用 while 循环来限制用户给出的输入数量。一旦循环变量与数组大小匹配，循环将停止接受输入并显示数组。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 走一条试捕道。
- 在 try 块中，要求用户初始化数组元素。
- 使用 while 循环进行同样的操作。
- 输入大于指定大小的元素。
- 这将引发 ArrayIndexOutOfBoundsException。
- 现在捕获块将打印消息“超出数组界限”...再试一次。
- 停止
下面是相同的代码。
下面的程序演示了如何在向数组输入元素时检查数组边界，方法是使用 while 循环限制输入。
/*Java Program to Check Array Bounds while Inputing elements into an Array*/
import java.util.*;
public class Main
{
// Main driver method
public static void main(String args[])
{
// Taking input from user
Scanner sc = new Scanner(System.in);
//Ask the user to enter the Array Size
int n;
System.out.println("Enter the Array Size ");
n=sc.nextInt();
// Storing user input elements in an array
int arr[] = new int[n];
int i = 0;
System.out.println("Enter the Array elements : ");
try{
// Condition check
while (true)
{
if (i == n+1)
// Statement to throw an exception
throw new ArrayIndexOutOfBoundsException();
arr[i++] = sc.nextInt();
}
}
catch (ArrayIndexOutOfBoundsException e)
{
// Print message when any exception occurs
System.out.println("Array Bounds Exceeded...");
System.out.println("Try Again");
}
}
}
输入数组大小 5
输入数组元素:7 9 5 6 4 3
超出数组界限...
再试一次
Java 程序：检查给定整数X在数组中出现次数是否超过N/2次
在本教程中，我们将学习如何查找给定的整数 X 在 N 个整数的排序数组中出现的次数是否超过 N/2 次。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:
数组:4 5 3 6 2 3 1 7
搜索元素:3
输出:
3 次发生不超过 4 次。
程序 1:查找给定的整数 X 在 N 个整数的排序数组中出现的次数是否超过 N/2 次。
在这种方法中，我们将看到如何通过使用循环来查找给定的整数 X 在 N 个整数的排序数组中出现的次数是否超过 N/2 次。使用这种方法背后的逻辑是，我们计算排序数组中元素的出现次数，然后将其与 n/2 值进行比较。需要记住的一点是，如果我们需要在计数元素出现之前先对数组进行排序。这将使我们的任务更容易，因为要搜索的 if 元素将位于相邻位置，这将使我们计算该变量出现次数的任务更容易。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 通过比较和交换数组对数组进行排序。
- 打印排序后的数组。
- 输入要检查其频率的元素。
- 使用两个 for 循环遍历数组的所有元素，并计算元素的频率。
- 第一个 for 循环用于保存数组元素。
- 第二个 for 循环用于检查剩余的数组元素。
- 使用 if 循环检查元素以前是否出现过。
- 如果该元素以前发生过，则递增计数变量。
- 如果元素出现次数超过 n/2 次，则打印该元素出现次数超过 n/2 次的消息。
- 如果元素出现次数不超过 n/2 次，则打印该元素出现次数不超过 n/2 次的消息。
- 停下来。
下面是相同的代码。
下面的程序演示了如何使用循环来查找给定的整数 X 在 N 个整数的排序数组中出现的次数是否超过 N/2 次。
/* Java Program to find the find if a given integer X appears more than N/2 times in a sorted Array of N integers using loops */
import java.util.*;
public class Main
{
// Main driver method
public static void main(String args[])
{
// Taking input from user
Scanner sc = new Scanner(System.in);
int n,x; //Declaring Variables
int count=0; //declare the variable and initialize it to 0
//Ask the user to enter the Array Size
System.out.println("Enter the Array Size ");
n=sc.nextInt();
//Declare the array
int arr[] = new int[n];
System.out.println("Enter the Array elements ");
for(int i=0;i<n;i++) //Ask the user to initialize the array
{
arr[i]=sc.nextInt();
}
//Use a for loop to Sort the Array
int temp; //Temporary variable to hold the element
System.out.print("Sorted Array: ");
for(int i = 0; i < n; i++) //Holds the array elements
{
for(int j = i + 1; j < n; j++) //Checks for the remaining elements
{
if(arr[i] > arr[j]) //Check for the condition
{
temp = arr[i]; //Sort by Swapping the variables
arr[i] = arr[j];
arr[j] = temp;
}
}
}
//Print the sorted array
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println("");
System.out.println("Enter the element which you want to check:");
x = sc.nextInt(); //Element that you want to check
for(int i = 0; i < n; i++)
{
if(arr[i] == x)
{
count++; //Increment the count each time the variable is found
}
}
//check whether the element has occurred for more than n/2 times
if(count > (n / 2))
{
System.out.println("Given Integer "+ x +" appears more than "+ n/2 + "times");
}
else
{
System.out.println("Given Integer "+ x +" does not appear more than "+ n/2 +" times");
}
}
}
输入数组大小 5
输入数组元素 6 7 5 4 3 5 6 9 6 6
排序数组:3 4 5 6 6 6 6 7 9
输入要检查的元素:6
给定整数 6 出现次数不超过 5 次
Java 程序：显示矩阵转置
原文：https://www.studytonight.com/java-programs/java-program-to-display-the-transpose-of-a-matrix
在本教程中，我们将学习如何显示矩阵的转置。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入矩阵元素:
1 2 3
4 5 3
9 3 2
输出:转置矩阵为:
1 4 3
2 5 3
3 3 2
程序 1:显示矩阵的转置
在这个程序中，我们将使用一个单独的矩阵来存储转置元素。
算法
- 开始
- 为矩阵行和列声明变量。
- 要求用户初始化行和列。
- 声明一个矩阵。
- 要求用户初始化矩阵元素。
- 打印原始矩阵。
- 声明另一个将存储转置矩阵元素的矩阵。
- 通过改变原始矩阵的行和列来存储转置矩阵中的元素。
- 显示转置矩阵。
- 停下来。
下面是相同的代码。
下面的程序演示了如何找到矩阵的转置。
/*JAVA PROGRAM TO DISPLAY THE TRANSPOSE OF A MATRIX*/
import java.util.*;
public class Main
{
public static void main(String []args)
{
///Take input from the user
Scanner sc=new Scanner(System.in);
int m,n; //Matrix Size Declaration
System.out.println("Enter the number of rows: \n");
m=sc.nextInt(); //Matrix Size Initialization
System.out.println("Enter the number of column: \n");
n=sc.nextInt(); //Matrix Size Initialization
int arr[][]=new int[10][10]; //Matrix Size Declaration
System.out.println("Enter the elements of the matrix: ");
for(int i=0;i<m;i++) //Matrix Initialization
{
for(int j=0;j<n;j++)
{
arr[i][j]=sc.nextInt();
}
}
//Print the original Matrix
System.out.println("The elements in the original matrix are: ");
for(int i=0;i<m;i++) //Print the matrix
{
for(int j=0;j<n;j++)
{
System.out.print(arr[i][j]+" ");
}
System.out.println("");
}
int brr[][]=new int[10][10]; //Transpose Matrix Declaration
for(int i=0;i<m;i++) //Transpose Matrix initialization
{
for(int j=0;j<n;j++)
{
brr[j][i]=arr[i][j]; //Store elements in the transpose matrix
}
}
System.out.println("After transposing the elements are...");
for(int i=0;i<m;i++) //Print the transpose matrix
{
for(int j=0;j<n;j++)
{
System.out.print(brr[i][j]+" ");
}
System.out.println("");
}
}
}
输入行数:3
输入列数:3
输入矩阵元素:5 4 3 1 2 6 9 8 7
原矩阵中的元素为:
5 4 3
1 2 6
9 8 7
转置后的元素为...
5 1 9
4 2 8
3 6 7
程序 2:显示矩阵的转置
在这个程序中，我们将使用相同的矩阵，但在打印时，我们将改变元素的位置。
算法
- 开始
- 为矩阵行和列声明变量。
- 要求用户初始化行和列。
- 声明一个矩阵。
- 要求用户初始化矩阵元素。
- 打印原始矩阵。
- 要打印转置矩阵，请更改行和列的位置。
- 显示矩阵。
- 停止
下面是相同的代码。
下面的程序演示了如何在不使用任何其他数组的情况下显示矩阵的转置。
/*JAVA PROGRAM TO DISPLAY THE TRANSPOSE OF A MATRIX*/
import java.util.*;
public class Main
{
public static void main(String []args)
{
///Take input from the user
Scanner sc=new Scanner(System.in);
int m,n; //Matrix Size Declaration
System.out.println("Enter the number of rows: \n");
m=sc.nextInt(); //Matrix Size Initialization
System.out.println("Enter the number of column: \n");
n=sc.nextInt(); //Matrix Size Initialization
int arr[][]=new int[10][10]; //Matrix Size Declaration
System.out.println("Enter the elements of the matrix: ");
for(int i=0;i<m;i++) //Matrix Initialization
{
for(int j=0;j<n;j++)
{
arr[i][j]=sc.nextInt();
}
}
//Print the original Matrix
System.out.println("The elements in the original matrix are: ");
for(int i=0;i<m;i++) //Print the matrix
{
for(int j=0;j<n;j++)
{
System.out.print(arr[i][j]+" ");
}
System.out.println("");
}
//Print the transpose matrix without creating any new matrix
System.out.println("After transposing the elements are...");
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
System.out.print(arr[j][i]+" ");
}
System.out.println("");
}
}
}
输入行数:3
输入列数:3
输入矩阵元素:9 8 7 6 7 2 3 1 3
原矩阵中的元素为:
9 8 7
6 7 2
3 1 3
转置后的元素为...
9 6 3
8 7 1
7 2 3
Java 程序：创建包含两个数组的交错数组
在本教程中，我们将学习如何创建包含两个数组的交错数组。交错数组被定义为一个数组，其中该数组的每个元素本身就是一个数组。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:
输入交错数组的行数:2
输入每行的列数:3 4
输入元素:1 2 3 4 5 6 7
输出:
数组的元素:
1 2 3
4 5 6 7
程序 1:创建交错数组
在这个方法中，我们将看到如何创建一个交错数组，该数组包含两个带有预定义输入的 1D 数组。
算法:
- 开始
- 声明数组的大小。
- 初始化交错数组的行数。
- 现在，初始化交错数组的数组。
- 首先，声明第一行的列数。
- 现在，声明第二行的列数。
- 为要打印的元素声明一个变量，并将其初始化为零。
- 开始初始化数组元素。
- 对同一个循环使用两个。
- 使用第一个 for 循环遍历行。
- 使用第二个 for 循环遍历列。
- 现在，通过增加 count 元素来初始化元素。
- 现在，使用两个 for 循环显示 2D 交错数组的值。
- 停止
下面是相同的代码。
下面的程序演示了如何创建包含两个预定义输入数组的交错数组
/*Java Program to to create a jagged array which contains two 1D array*/
public class Main
{
public static void main(String[] args)
{
// Declaring 2-D array with 2 rows
int arr[][] = new int[2][];
// Initializing the arrays of jagged arrays
// First row has 4 columns
arr[0] = new int[4];
// Second row has 5 columns
arr[1] = new int[5];
// Initializing array
int count = 0;
for (int i = 0; i < arr.length; i++) //For Rows
{
for (int j = 0; j < arr[i].length; j++) //For Columns
{
arr[i][j] = count++;
}
}
// Displaying the values of 2D Jagged array
System.out.println("Elements of 2D Jagged Array");
for (int i = 0; i < arr.length; i++)
{
for (int j = 0; j < arr[i].length; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
2D 锯齿状数组的元素
0 1 2 3
4 5 6 7 8
程序 2:创建交错数组
在这个方法中，我们将看到如何创建一个交错数组，该数组包含两个带有用户定义输入的 1D 数组。
算法
- 开始
- 声明数组的大小。
- 要求用户初始化交错数组的行数。
- 要求用户为交错数组初始化每行的列数。
- 对相同的使用 for 循环。
- 开始初始化数组元素。
- 对同一个循环使用两个。
- 使用第一个 for 循环遍历行。
- 使用第二个 for 循环遍历列。
- 现在，通过增加 count 元素来初始化元素。
- 现在，使用两个 for 循环显示 2D 交错数组的值。
- 停止
下面是相同的代码。
下面的程序演示了如何创建包含两个用户定义输入的 1D 数组的交错数组。
/*Java Program to to create a jagged array which contains two 1D array*/
import java.util.*;
public class Main
{
public static void main(String[] args)
{
//Taking Input from the user
Scanner sc=new Scanner(System.in);
//Declare number of rows for jagged array
int m;
System.out.println("Enter the number of rows for jagged arrays");
m=sc.nextInt(); //Initialize the number of rows for jagged array
// Declaring 2-D array with m rows
int arr[][] = new int[m][];
//Initializing the columns for each rows of jagged array
System.out.println("Enter the number of columns for each rows of jagged arrays");
for(int i=0;i<m;i++)
{
arr[i]=new int[sc.nextInt()];
}
// Initializing array
System.out.println("Enter the elements");
for (int i = 0; i < arr.length; i++) //For Rows
{
for (int j = 0; j < arr[i].length; j++) //For Columns
{
arr[i][j] = sc.nextInt();
}
}
// Displaying the values of 2D Jagged array
System.out.println("Elements of 2D Jagged Array");
for (int i = 0; i < arr.length; i++) //For Rows
{
for (int j = 0; j < arr[i].length; j++) //For Columns
{
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
输入交错数组的行数 2
输入交错数组每一行的列数 3 4
输入元素 1 2 3 4 5 6 7
2D 交错数组的元素
1 2 3
4 5 6 7
Java 程序：打印数组第k个元素
原文：https://www.studytonight.com/java-programs/java-program-to-print-the-kth-element-of-array
在本教程中，我们将学习如何打印数组中的第 k 个元素。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:
数组元素:4 6 2 1 8 9 4 3 6 8 9
输入您想知道其元素的位置:5
输出:位置 5 的元素为 8
程序 1:打印数组中的第 k 个元素
在这种情况下，我们将看到当程序中预定义了值时，如何打印数组中的第 k 个元素。这意味着这些值已经在程序中定义了，我们的任务是编写一个程序，这样它将打印指定位置的元素。
算法
- 开始
- 声明一个数组。
- 在程序中初始化数组。
- 打印数组的元素。
- 声明一个存储位置值的变量。
- 初始化您想要知道其元素的位置。
- 打印该位置的元素。
- 停止
下面是相同的代码。
下面的程序演示了如何打印数组中的第 k 个元素。
// Java Program to Print the kth Element in the Array with pre defined elements
import java.io.*;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
// declare and intialize the array
int a[] = {3, 5, 7, 1 , 2, 9 , 8 , 1 , 4, 7 };
//Print the Array elements
System.out.println("Elements in the array ");
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
System.out.println("");
System.out.println("The position at which you want to check number:");
int k = 5;
//Print the element at kth position
if(k<a.length)
{
System.out.println("Element at "+ k +"th position is " + a[k - 1]);
}
else
{
System.out.println("Enter valid position");
}
}
}
数组中的元素
3 5 7 1 2 9 8 1 4 7
您要检查编号的位置:
第 5 个位置的元素是 2
程序 2:打印第 k 个元素
在这种情况下，我们将看到当程序中的值是用户定义的时，如何打印数组中的第 k 个元素。这意味着这里的值是由用户提供的，我们在这里的任务是编写一个程序，这样它将打印在指定位置出现的元素。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小
- 声明一个数组。
- 要求用户初始化数组元素。
- 声明一个变量来存储数组的位置。
- 要求用户初始化数组位置。
- 在该位置打印元素。
- 停止
下面是相同的代码。
下面的程序演示了如何打印数组中的第 k 个元素。我们将要求用户输入元素想要知道的位置的值。
// Java Program to Print the kth Element in the Array with User Defined elements
import java.io.*;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
int n;
// scanner object to acces user input
Scanner s = new Scanner(System.in);
System.out.print("Enter the number of elements in the array:");
// Ask the user to initialize the array size
n = s.nextInt();
// declare an array
int a[] = new int[n];
System.out.println("Enter all the elements of the array:");
// Ask the user to initializing the array elements using a for loop
for (int i = 0; i < n; i++)
{
a[i] = s.nextInt();
}
System.out.println("Enter the position at which you want to check number:");
//Ask the user to intialize the position
int k = s.nextInt();
//Print the element at kth position
System.out.println("Element at "+ k +"th position is " + a[k - 1]);
}
}
输入数组中的元素个数:10
输入数组中的所有元素:2 3 4 6 1 2 9 8 7 6
输入要检查的位置个数:4
第 4 个位置的元素为 6
Java 程序：打印数组中奇数和偶数
在本教程中，我们将学习如何打印数组的偶数和奇数。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入数组元素:5 4 3 6 7 8 9 4 2 1
输出:偶数元素:4 2 6 8 4 2
奇数元素:5 3 7 9 1
程序 1:找出数组的偶数和奇数元素
在这种方法中，我们将看到如何在主方法中找到数组的偶数和奇数元素。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明一个数组。
- 要求用户初始化数组元素。
- 通过检查用于循环的条件来打印偶数元素。
- 通过检查用于循环的条件来打印奇数元素。
- 停止
下面是相同的代码。
下面的例子演示了如何找到数组的偶数和奇数元素。
// Java Program to Print the even and odd Element of the Array
import java.io.*;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
int n; //Declare size of an array
System.out.println("Enter the size of the array: ");
n=sc.nextInt(); //Intialize the array size
int arr[]=new int[n]; //Declare an array
System.out.println("Enter the array elements: ");
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt(); //Initialize the array elements
}
//Print the even elements
System.out.println("The Even Elements are...");
for(int i=0;i<n;i++)
{
if(arr[i]%2==0) //Check whether even or not
{
System.out.print(arr[i]+" ");
}
}
System.out.println(" ");
//Print the odd elements
System.out.println("The Odd Elements are...");
for(int i=0;i<n;i++)
{
if(arr[i]%2!=0) //check whether odd or not
{
System.out.print(arr[i]+" ");
}
}
}
}
输入数组大小:10
输入数组元素:1 3 2 4 3 1 6 8 9
偶数元素为...
2 4 6 8
奇数元素是...
1 3 1 9
程序 2:寻找数组的偶数和奇数元素
在这种方法中，我们将看到如何通过对每个元素使用不同的方法来找到数组的偶数和奇数元素。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明一个数组。
- 要求用户初始化数组元素。
- 调用方法检查偶数元素。
- 打印偶数元素。
- 调用另一个方法来检查奇数元素。
- 打印奇数元素。
- 停止
下面是相同的代码。
下面的示例演示了如何使用不同的方法来查找数组的偶数和奇数元素。
// Java Program to Print the even and odd Element of the Array
import java.io.*;
import java.util.Scanner;
public class Main
{
//Driver Method
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
int n; //Declare size of an array
System.out.println("Enter the size of the array: ");
n=sc.nextInt(); //Intialize the array size
int arr[]=new int[n]; //Declare an array
System.out.println("Enter the array elements: ");
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt(); //Initialize the array elements
}
System.out.println("The Even Elements are...");
printEven(arr,n); //Method to print even elements
System.out.println(" ");
System.out.println("The Odd Elements are...");
printOdd(arr,n); //Method to print odd elements
}
//Method to print the even elements
static void printEven(int arr[], int n)
{
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
{
System.out.print(arr[i]+" ");
}
}
}
//Method to print the odd elements
static void printOdd(int arr[], int n)
{
for(int i=0;i<n;i++)
{
if(arr[i]%2!=0)
{
System.out.print(arr[i]+" ");
}
}
}
}
输入数组大小:10
输入数组元素:6 9 8 7 3 4 5 2 1 2
偶数元素为...
6 8 4 2 2
奇数元素是...
9 7 3 5 1
Java 程序：在给定的排序数组中查找元素的上界和下界值
在本教程中，我们将学习如何在给定的排序数组中找到元素的上界和下界值。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:
数组:15 17 18 19 20 21 22 24 25 26 27
要素:16
输出:
楼层:15
上界:17
上述问题可以通过两种方式解决:
方法 1:二分搜索法
方法 2:线性搜索
让我们分别看看这些方法。
程序 1:在给定的排序数组中找到元素的上界和下界值
在这种方法中，我们只需执行二分搜索法运算，即可找到给定排序数组中元素的下限和上限值。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明一个数组。
- 要求用户初始化数组。
- 声明一个变量来存储要搜索的元素的值。
- 调用一个方法来检查上界值。
- 将 ceil 初始化为-1，然后遍历元素以搜索 ceil 值。
- 在上界方法中，如果 x 等于中间元素，那么它就是上界值。
- 如果 x 小于中间元素，则上界值位于左子数组中。更新上限值，并在 A[低，中 1]中再次搜索。
- 如果 x 大于中间元素，则上界值位于右子数组中。更新上限值，并在 A[中间，结束]中再次搜索。返回找到的上界值。
- 调用一个方法来检查下界值。
- 将 floor 初始化为-1，然后遍历元素以搜索 floor 值。
- 在 floor 方法中，如果 x 等于中间元素，那么它就是 floor 值。
- 如果 x 小于中间元素，则下界值位于左侧子数组中。更新下界值，并在 A[低，中 1]中再次搜索。
- 如果 x 大于中间元素，则下界值位于右子数组中。更新下界值，并在 A[中，高]中再次搜索。
- 返回找到的下界值。
- 显示上界和下界值。
- 停止
下面是相同的代码。
下面的程序演示了如何在给定的排序数组中找到元素的上界和下界值
// Java Program to find the ceil and floor of an element in an array
import java.io.*;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
int n; //Declare size of an array
System.out.println("Enter the size of the array: ");
n=sc.nextInt(); //Initialize the array size
int arr[]=new int[n]; //Declare an array
System.out.println("Enter the array elements: ");
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt(); //Initialize the array elements
}
//Enter the element whose floor and ceil values you want to check
int x;
System.out.println("Enter the element whose floor and ceil values you want to check: ");
x=sc.nextInt();
//Method to check for Ceil
int ceil=getCeil(arr,x);
//Print the Ceil value
System.out.println("Ceil value is "+ceil);
//Method to check for Floor
int floor=getFloor(arr,x);
//Print the floor Value
System.out.println("floor value is "+floor);
}
// Function to find the ceil of X in a sorted array A[],i.e., the smallest integer greater than or equal to X
public static int getCeil(int[] A, int x)
{
// search space is A[left…right]
int left = 0, right = A.length - 1;
// initialize ceil to -1
int ceil = -1;
// loop till the search space is exhausted
while (left <= right)
{
// find the mid-value in the search space
int mid = (left + right) / 2;
// if X is equal to the middle element, it is the ceil
if (A[mid] == x) {
return A[mid];
}
// if X is less than the middle element, the ceil exists in the subarray A[left…mid]; update ceil to the middle element and reduce our search space to the left subarray A[left…mid-1]
else if (x < A[mid])
{
ceil = A[mid];
right = mid - 1;
}
// if X is more than the middle element, the ceil exists in the right subarray A[mid+1…right]
else
{
left = mid + 1;
}
}
return ceil;
}
// Function to find the floor of X in a sorted array A[], i.e., the largest integer less than or equal to X
public static int getFloor(int[] A, int x)
{
int left = 0, right = A.length - 1;
// initialize floor to -1
int floor = -1;
// loop till the search space is exhausted
while (left <= right)
{
// find the mid-value in the search space
int mid = (left + right) / 2;
// if X is equal to the middle element, it is the floor
if (A[mid] == x)
{
return A[mid];
}
// if X is less than the middle element, the floor exists in the left subarray A[left…mid-1]
else if (x < A[mid]) {
right = mid - 1;
}
// if X is more than the middle element, the floor exists in the subarray A[mid…right]; update floor to the middle element and reduce our search space to the right subarray A[mid+1…right]
else {
floor = A[mid];
left = mid + 1;
}
}
return floor;
}
}
输入数组的大小:10
输入数组元素:1 2 3 4 6 7 8 9 10 11
输入要检查其楼层和上界值的元素:5
上界值为 6
楼层值为 4
程序 2:在给定的排序数组中找到元素的上界和下界值
在这种方法中，我们只需执行线性搜索，就可以在给定的排序数组中找到元素的下限和上限。
算法
- 开始
- 声明一个排序数组。
- 声明一个变量来存储排序数组的长度。
- 输入要检查其楼层和上界值的数字。
- 要查找下界值，请遍历数组。
- 如果当前元素大于输入的元素，则打印前一个数字并中断循环。
- 如果没有大于输入元素的数字，则打印最后一个元素
- 如果第一个数字大于输入的元素，则打印-1。
- 同样，如果输入的元素小于或等于数组中的第一个元素，则返回 0。
- 否则遍历数组找到一个比输入的数字小的数字。
- 如果没有找到这样的元素，那么返回-1。
- 显示两个结果。
- 停下来。
下面是相同的代码
/*Java Program to check for Ceil and Floor value*/
public class Main
{
//Check For Ceil Value
static int ceilSearch(int arr[], int low, int high, int x)
{
int i;
if(x <= arr[low])
return low;
for(i = low; i < high; i++)
{
if(arr[i] == x)
return i;
if(arr[i] < x && arr[i+1] >= x)
return i+1;
}
return -1;
}
//Check for floor value
static int floorSearch(int arr[], int n, int x)
{
if (x >= arr[n - 1])
return n - 1;
if (x < arr[0])
return -1;
for (int i = 1; i < n; i++)
if (arr[i] > x)
return (i - 1);
return -1;
}
// Driver program
public static void main (String[] args)
{
int arr[] = {1, 2, 3 , 4, 7, 8, 9, 10};
int n = arr.length;
int x = 11;
int ceil = ceilSearch(arr, 0, n-1, x);
if(ceil == -1)
System.out.println("Ceiling of "+x +" doesn't exist in array");
else
System.out.println("ceiling of "+x+" is "+arr[ceil]);
int floor = floorSearch(arr, n - 1, x);
if (floor == -1)
System.out.print( "Floor of " + x + " doesn't exist in array ");
else
System.out.print("Floor of " + x + " is " + arr[floor]);
}
}
数组中不存在 11 的上限
11 的下限为 9
Java 程序：打印数组中所有重复的数字
在本教程中，我们将学习如何在一个数组中按频率打印所有重复的数字。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入数组元素:2 4 3 5 2 3 4 6 7 8 9 6 5 4
输出:重复频率的元素:
元素频率
2 2
3 2
4 3
5 2
6 2
上述问题可以通过以下方式解决:
让我们分别看看这些方法。
程序 1:在一个数组中找到有频率的重复数
在这种方法中，我们将使用HashMap来打印数组中具有频率的重复数字。该方法的时间和空间复杂度为 O(n)。
算法
- 开始
- 声明一个变量来存储数组元素
- 要求用户初始化变量。
- 声明一个数组。
- 请用户初始化该数组。
- 为相同的声明一个 hashmap。
- 使用 for 循环检查映射是否包含重复元素。
- 如果发现重复元素，则将该元素的索引增加 1。
- 如果没有找到重复的元素，那么就给它分配一个。
- 开始打印元素。
- 仅当计数大于 1 时才打印元素。
- 停下来。
下面是相同的代码。
下面的程序演示了如何使用 Hashmap 打印数组中的重复元素。映射会节省很多空间和时间。
/*Java Proggram to find the repeated elements with Frequency*/
import java.util.*;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
int n; //Declare variable for array size
System.out.println("Enter the length of the array");
n=sc.nextInt(); //Ask the user to initialize the size of the array
int a[]=new int[n]; //declare Array
System.out.println("Enter the array elements ");
for(int i=0;i<n;i++)
{
a[i]=sc.nextInt(); //Initialize Array elements
}
//Hashmap for array elements
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
if (map.containsKey(a[i]))
{
// if duplicate element in the map then increase the value of element at index by 1
int c = map.get(a[i]);
map.replace(a[i], c + 1);
}
// if not a duplicate element in map than assign it by 1\.
else
map.put(a[i], 1);
}
//Print the Repeated Elements with Frequency
System.out.println("Elements Frequency");
for (Map.Entry<Integer, Integer> i : map.entrySet())
{
// print only if count of element is greater than 1\.
if (i.getValue() > 1)
System.out.println(" "+ i.getKey() + " "+ i.getValue());
else
continue;
}
}
}
输入数组 10 的长度
输入数组元素 2 3 1 2 3 6 1 8 9
元素频率
1 2
2 3
3 2
程序 2:找出数组中重复出现的频率数
在这个方法中，我们将看到如何使用另一个数组打印一个数组中的重复数字。
算法
- 开始
- 声明一个变量来存储数组大小。
- 要求用户初始化该变量。
- 声明一个数组。
- 请用户初始化该数组。
- 声明一个变量 max 并用 Integer 赋值。最小值。
- 声明另一个数组来存储所有变量的频率。
- 计算每个变量的频率。
- 仅当元素的频率大于 1 时，才打印元素及其频率。
- 显示输出。
- 停止
下面是相同的代码。
下面的程序演示了如何使用另一个查找数组中重复的元素。这个新数组用于存储每个元素的频率，然后只打印那些频率大于 1 的元素。
/*Java Proggram to find the repeated elements with Frequency*/
import java.util.*;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
int n; //Declare variable for array size
System.out.println("Enter the length of the array");
n=sc.nextInt(); //Ask the user to initialize the size of the array
int arr[]=new int[n]; //declare Array
System.out.println("Enter the array elements ");
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt(); //Initialize Array elements
}
int max = Integer.MIN_VALUE;
for (int i = 0; i < n; i++) {
if (arr[i] > max)
max = arr[i];
}
int brr[] = new int[max + 1]; //Declare another Array to store the frequency
for (int i = 0; i < n; i++)
{
// increment in array brr for every integer in arr.
brr[arr[i]]++;
}
System.out.println("Element Frequency ");
for (int i = 0; i <= max; i++) {
// output only if element is more than 1 time in array A.
if (brr[i] > 1)
System.out.println(" " + i + " " + brr[i]);
}
}
}
输入数组 15 的长度
输入数组元素 2 3 1 2 3 6 1 8 9 6 8 3 4 6
元素频率
1 2
2 3
3 3
6 3
8 2
Java 程序：计算数组中元素个数
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-number-of-elements-in-an-array
在本教程中，我们将学习如何查找数组中存在的元素总数。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:数组元素为:9 8 7 0 6 5 4 3 4 5 2 1
输出:数组中的元素总数为 13
程序 1:计算数组中元素的数量
在这个方法中，我们将看到如何使用每个循环的来计算数组中存在的元素数量。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 声明一个变量计数来存储数组中的元素数量。
- 将其初始化为 0。
- 对每个循环使用，以迭代数组中的所有元素。
- 在每次迭代中增加计数变量。
- 打印数组中元素的总数。
- 现在，打印数组元素。
- 停下来。
下面的程序演示了如何为每个循环使用计算数组中元素的总数。首先，我们声明一个数组，然后对每个循环使用一个来确定数组中存在的元素总数。
/*Java Program to find the number of elements present in an array*/
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
int a[] = {9,8 ,7 ,0 ,6 ,5 ,4 ,7 ,3 ,4 ,5 ,2 ,1}; //Declare and Initialize an array
int count=0; //Declare variable to count the number of elements in an array and initialize it to 0
//Use a for each loop to iterate through all the elements in an array
//Print the elements present in the array
System.out.println("The entered elements are: ");
for(int i:a)
{
System.out.print(a[i]+" ");
count++; //Increment the count variable
}
System.out.println("");
//Print the total number of elements present
System.out.println("The total number of elements in an array is "+count);
}
}
输入的元素是:
4 3 7 9 4 5 6 7 0 6 5 7 8
数组中的元素总数是 13
程序 2:计算数组中元素的数量
在这个方法中，我们将看到如何使用内置函数计算数组中存在的元素数量。Java 提供了一个内置函数length()，返回数组的总长度。数组的总长度只不过是数组中元素的总数。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 声明一个变量计数来存储数组中的元素数量。
- 使用内置函数计算数组的长度。
- 打印数组的长度。
- 使用 for 循环遍历所有元素。
- 打印所有数组元素。
- 停下来。
下面是相同的代码。
下面的程序演示了如何使用 try-catch 块计算数组中的元素总数。首先，我们声明并初始化数组，然后使用内置函数来确定数组中存在的元素总数。
/*Java Program to find the number of elements present in an Array using in-built functions*/
public class Main
{
//Driver Code
public static void main(String[] arr)
{
int a[] = {91,28 ,47 ,30 ,56 ,65 ,74 ,87 ,93 ,24 ,15 ,82 }; //Declare and Initialize an array
//Declare a variable to store the length of the array
int count=a.length; //Use an in-built function to calculate the length of an array
System.out.println("The number of elements in the array are : "+count); //Print the length of the array
//Print the array elements
System.out.println("The Array Elements are ");
for(int j=0;j<count;j++)
{
System.out.print(a[j]+" ");
}
System.out.println("");
}
}
数组中的元素个数为:12
数组元素为
91 28 47 30 56 65 74 87 93 24 15 82
Java 程序：计算矩阵中奇数和偶数频率
在本教程中，我们将学习如何找到矩阵中奇数和偶数的频率。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
下面是矩阵的图示。
输入:输入矩阵元素:
1 2 3
4 3 2
6 7 8
输出:
偶素频率:5
奇数元素频率:4
程序 1:找出矩阵中奇数和偶数的频率
在下面的程序中，我们将看到当值是用户定义的时，如何计算给定矩阵中奇数和偶数的频率。
算法
- 开始
- 为矩阵行和列声明变量。
- 请用户初始化矩阵。
- 声明矩阵。
- 请用户初始化矩阵。
- 打印原始矩阵..
- 声明两个变量来计算偶数和奇数频率。
- 将这些变量初始化为 0。
- 使用两个 for 循环遍历元素。
- 使用第一个 for 循环遍历行。
- 使用第二个 for 循环遍历列。
- 检查每个元素。
- 如果矩阵元素为偶数，则递增偶数计数变量。
- 如果矩阵元素是奇数，递增奇数计数变量。
- 打印数组中偶数和奇数元素的频率。
- 停下来。
下面是相同的代码。
/* Java Program to check the even and odd element frequencies*/
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
int m,n; //Declare the variables for rows and columns
//Take input from the user
Scanner sc = new Scanner(System.in);
System.out.print("Enter number of rows in matrix:");
m = sc.nextInt(); //Initialize the number of rows
System.out.print("Enter number of columns in matrix:");
n = sc.nextInt(); //Initialize the number of columns
int arr[][] = new int[m][n]; //Declare a Matrix
System.out.println("Enter all the elements of matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
arr[i][j] = sc.nextInt(); //Initialize the Matrix
}
}
//Print the original Matrix
System.out.println("The Original Matrix:");
for (int i = 0; i < m; i++) //Used to iterate over the matrix rows
{
for (int j = 0; j < n; j++) //Used to iterate over the matrix columns
{
System.out.print(arr[i][j] + " ");
}
System.out.println("");
}
int even=0,odd=0; //Variables to store even and odd elements
//Use for loops to iterate through the matrix elements
for(int i=0;i<m;i++) //Used to iterate over the matrix rows
{
for(int j=0;j<n;j++) //Used to iterate over the matrix columns
{
if(arr[i][j]%2==0) //Check whether the element is even or not
{
even++; //Increment the even frequency
}
else
{
odd++; //Increment the odd frequency
}
}
}
System.out.println("Total Odd Number in the Matrix: " + odd);
System.out.println("Total Even Number in the Matrix: " + even);
}
}
输入矩阵行数:3
输入矩数组数:3
输入矩阵所有元素:1 2 3 4 5 6 7 8 9
原矩阵:
1 2 3
4 5 6
7 8 9
矩阵总奇数:5
矩阵总偶数:4
程序 2:求矩阵中奇数和偶数的频率
在下面的程序中，我们将看到当值被预定义时，如何计算给定矩阵中奇数和偶数的频率。
算法
- 开始
- 声明一个矩阵并将其初始化为 0。
- 调用一个方法来计算偶数和奇数频率。
- 使用 for 循环迭代元素。
- 每次遇到偶数元素时增加偶数计数。
- 每次遇到奇数元素时增加奇数计数。
- 打印数组中偶数和奇数元素的频率。
- 停止
下面是相同的代码。
/*Java Program to find the trace and normal of a matrix*/
import java.io.*;
public class Main
{
//To Find the normal of a matrix
public static void findNormal(int[][] arr)
{
double square = 0, result = 0;
System.out.println("The Normal of the above matrix is ");
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[0].length; j++)
{
square = square + (arr[i][j])*(arr[i][j]);
}
}
result = Math.sqrt(square);
System.out.println(result);
}
//To Find the trace of a matrix
public static void findTrace(int[][] arr)
{
double sum = 0;
System.out.println("The Trace of the above matrix is ");
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[0].length; j++)
{
if(i == j)
{
sum = sum + (arr[i][j]);
}
}
}
System.out.println(sum);
}
// Driver code
public static void main(String args[]) throws IOException
{
int arr[][]
= { { 2, 9, 8 }, { 7, 6, 4 }, { 3, 9, 2 } }; //Matrix Declaration and Initialization
System.out.println("Original Matrix");
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[0].length; j++)
{
System.out.print(arr[i][j]+ " ");
}
System.out.println();
}
System.out.println();
findTrace(arr); //Find the Trace of the Matrix
System.out.println();
findNormal(arr); //Find the Normal of the Matrix
}
}
原始矩阵
2 9 8
7 6 4
3 9 2
上述矩阵的迹线为
10.0
上述矩阵的法线为
18 . 36960 . 666666666616
Java 程序：交换给定矩阵中任意两行和列
在本教程中，我们将学习如何交换给定矩阵中的任意两行和列。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
下面是给定矩阵中任意两行和列互换的图示。
输入:进入矩阵:
1 2 3
4 5 6
7 8 9
输出:交换行后:2 和 3
1 2 3
7 8 9
4 5 6
交换柱后:1 和 3
3 2 1
9 8 7
6 5 4
程序 1:交换任意两行和列
在这个程序中，我们将看到当值是用户定义的时，如何交换给定矩阵中的任意两行和列。
算法
- 开始
- 为行和列的大小声明变量。
- 要求用户初始化行数和列数。
- 声明一个具有该大小的矩阵。
- 请用户初始化矩阵。
- 打印原始矩阵。
- 使用 while 循环检查用户是否希望交换行或列，或者不交换。
- 使用循环分别交换行和列。
- 询问用户他/她想要交换哪两行或哪列。
- 基于此交换行或列元素。
- 显示结果。
- 停止
下面是相同的代码。
/*Java Program to interchange any two rows and columns in the given matrix*/
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
int m,n; //Declare the variables for rows and columns
//Take input from the user
Scanner sc = new Scanner(System.in);
System.out.print("Enter number of rows in matrix:");
m = sc.nextInt(); //Initialize the number of rows
System.out.print("Enter number of columns in matrix:");
n = sc.nextInt(); //Initialize the number of columns
int arr[][] = new int[m][n]; //Declare a Matrix
System.out.println("Enter all the elements of matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
arr[i][j] = sc.nextInt();
}
}
//Print the original matrix
System.out.println("The Original Matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println("");
}
//Check whether user want to interchange rows or columns
while (true)
{
System.out.println("Enter 1 to interchange rows");
System.out.println("Enter 2 to interchange columns");
System.out.println("Enter 3 to Exit");
int n1=sc.nextInt();
switch (n1)
{
case 1:
//Enter the rows whose datas you want to interchange
System.out.println("Enter the row numbers:");
int x = sc.nextInt();
int y = sc.nextInt();
int temp=0;
for(int i = 0; i < m; i++)
{
temp = arr[(x-1)][i];
arr[x-1][i] = arr[y-1][i];
arr[y-1][i] = temp;
}
//Print the matrix after interchanging elements
System.out.println("Matrix after interchanging rows:"+x +" and "+y);
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println("");
}
break;
case 2:
//Enter the columns whose datas you want to interchange
System.out.println("Enter the column numbers:");
int p = sc.nextInt();
int q = sc.nextInt();
int temp1=0;
for(int i = 0; i < p; i++)
{
temp1 = arr[i][(p-1)];
arr[i][p-1] = arr[i][(q-1)];
arr[i][q-1] = temp1;
}
//Print the matrix after interchanging elements
System.out.println("Matrix after interchanging columns:"+p +" and "+q);
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println("");
}
break;
case 3:
//Exit from the program
System.exit(0);
}
}
}
}
输入矩阵行数:3
输入矩数组数:3
输入矩阵所有元素:1 2 3 4 5 6 7 8 9
原矩阵:
1 2 3
4 5 6
7 8 9
输入 1 互换行
输入 2 互换列
输入 3 退出
1
互换行后输入行号:3 2
矩阵:3 和 2
1 2 3
7 8 9
4 5 6
输入 1 互换行
输入 2 互换列
输入 3 退出
2
互换列后输入列号:1 3
矩阵:1 和 3
3 2 1
7 8 9
4 5 6
输入 1 互换行
输入 2 互换列
输入 3 退出
3
程序 2:交换任意两行和列
在这个程序中，我们将看到当值被预定义时，如何交换给定矩阵中的任意两行和列。
算法
- 开始
- 声明并初始化矩阵。
- 打印原始矩阵。
- 输入要互换的列。
- 调用方法来交换列。
- 交换数字以交换列。
- 交换列后打印矩阵。
- 现在，调用一个方法来交换行。
- 交换数字以交换行。
- 交换行后打印矩阵。
- 停下来。
下面是相同的代码。
/*Java Program to interchange any two rows and columns*/
import java.io.*;
public class Main
{
//To Print the arr
public static void printMatrix(int[][] arr)
{
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[0].length; j++)
System.out.print(arr[i][j] + " ");
System.out.println();
}
}
//To Interchange Columns
public static void interchangeColumns(int[][] arr,
int K, int L)
{
for (int i = 0; i < arr.length; i++) {
// Swap two numbers
int temp = arr[i][K - 1];
arr[i][K - 1] = arr[i][L - 1];
arr[i][L - 1] = temp;
}
System.out.println("After Interchanging Column "+ K + " and "+ L+ " :");
// Print arr
printMatrix(arr);
}
//To Interchange Rows
public static void interchangeRows(int[][] arr, int x, int y)
{
for (int i = 0; i < arr[0].length; i++) {
// Swap two numbers
int temp = arr[x - 1][i];
arr[x - 1][i] = arr[y - 1][i];
arr[y - 1][i] = temp;
}
System.out.println("After Interchanging Row "+ x + " and "+ y + " :");
// Print arr
printMatrix(arr);
}
// Driver code
public static void main(String args[]) throws IOException
{
int arr[][]
= { { 2, 9, 8 }, { 7, 6, 4 }, { 3, 9, 2 } }; //Matrix Declaration and Initialization
//Print Original arr
System.out.println("Original arr: ");
printMatrix(arr);
// calling to exchange Columns
int K = 1, L = 2;
interchangeColumns(arr, K, L);
// calling to exchange Rows
int K1 = 1, L1 = 2;
interchangeRows(arr, K1, L1);
}
}
第 1 列和第 2 列互换后
9 2 8
6 7 4
7 6 4
3 9 2
第 1 列和第 2 列互换后:
9 2 8
6 7 4
9 3 2
第 1 排和第 2 排互换后:
6 7 4
9 2 8
9 3 2
Java 程序：从用户输入中相加两个M*N矩阵
原文：https://www.studytonight.com/java-programs/java-program-to-add-two-mn-matrix-from-user-input
在本教程中，我们将学习如何从用户输入中相加两个 M*N 矩阵。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
下面是同样的图示。
输入:
输入第一个矩阵的行数:3
输入第一个矩阵的列数:3
在第二个矩阵中输入行数:3
在第二个矩阵中输入行数:3
输入第一个矩阵的所有元素:1 2 3 4 5 6 7 8 9
输入第二个矩阵的所有元素:9 8 7 6 5 4 3 2 1
输出:
第一个矩阵:
1 2 3
4 5 6
7 8 9
第二个矩阵:
9 8 7
6 5 4
3 2 1
结果矩阵:
10 10 10
10 10 10
10 10 10
程序 1:从用户输入中相加一个 M*N 矩阵
在这个程序中，我们将执行矩阵加法。只有当给定矩阵的大小相同，即两个矩阵的行数和列数应该相同时，才能相加矩阵。
算法
- 开始
- 声明矩阵大小的变量
- 初始化第一个矩阵的行数和列数。
- 初始化第二个矩阵的行数和列数。
- 检查两个矩阵的大小是否相等。
- 如果相等，请用户初始化两个矩阵。
- 初始化后，打印两个矩阵。
- 创建一个新矩阵来存储两个矩阵的总和。
- 遍历这两个矩阵的每个元素，然后将它们相加。
- 将此总和存储在新矩阵中相应的索引处。
- 返回结果矩阵。
- 打印结果矩阵。
- 如果两个矩阵的大小不相等，则打印一条消息重试。
- 停下来。
下面是相同的 Java 语言代码。
/*Java Program to add two matrix*/
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
int p, q, m, n; //Declare matrix size
Scanner sc = new Scanner(System.in);
System.out.print("Enter the number of rows in the first matrix:");
p = sc.nextInt(); //Initialize first matrix size
System.out.print("Enter the number of columns in the first matrix:");
q = sc.nextInt(); //Initialize first matrix size
System.out.print("Enter the number of rows in the second matrix:");
m = sc.nextInt(); //Initialize second matrix size
System.out.print("Enter the number of columns in the second matrix:");
n = sc.nextInt(); //Initialize second matrix size
if (p == m && q == n)
{
int a[][] = new int[p][q]; //Declare first matrix
int b[][] = new int[m][n]; //Declare second matrix
int c[][] = new int[m][n]; //Declare third matrix
//Initialize the first matrix
System.out.println("Enter all the elements of first matrix:");
for (int i = 0; i < p; i++)
{
for (int j = 0; j < q; j++)
{
a[i][j] = sc.nextInt();
}
}
System.out.println("");
//Initialize the second matrix
System.out.println("Enter all the elements of second matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
b[i][j] = sc.nextInt();
}
}
System.out.println("");
//Print the first matrix
System.out.println("First Matrix:");
for (int i = 0; i < p; i++)
{
for (int j = 0; j < q; j++)
{
System.out.print(a[i][j]+" ");
}
System.out.println("");
}
//Print the second matrix
System.out.println("Second Matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(b[i][j]+" ");
}
System.out.println("");
}
//Loop to add matrix elements
for (int i = 0; i < p; i++)
{
for (int j = 0; j < n; j++)
{
for (int k = 0; k < q; k++)
{
c[i][j] = a[i][j] + b[i][j];
}
}
}
//Print the resultant matrix
System.out.println("Matrix after addition:");
for (int i = 0; i < p; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(c[i][j]+" ");
}
System.out.println("");
}
}
else
{
System.out.println("Addition not possible");
System.out.println("Try Again");
}
}
}
输入第一个矩阵的行数:3
输入第一个矩阵的列数:3
输入第二个矩阵的行数:3
输入第二个矩阵的列数:3
输入第一个矩阵的所有元素:1 2 3 4 5 6 7 8 9
输入第二个矩阵的所有元素:9 8 7 6 5 4 3 2 1
第一个矩阵:
1 2 3
4 5 6
7 8 9
第二个矩阵:
9 8 7
6 5 4
3 2 1
相加后的矩阵:
10 10 10 10
10 10
10 10 10
程序 2:从用户输入中相加一个 M*N 矩阵
在这个程序中，我们将相加两个矩阵。当给出 mn 和 mn 阶的两个矩阵时，产生的结果矩阵将是 m*n 阶的。这里要注意的一点是，为了执行矩阵加法，矩阵应该是相同阶的。
算法
- 开始
- 声明矩阵大小的变量
- 初始化第一个矩阵的行数和列数。
- 初始化第二个矩阵的行数和列数。
- 检查两个矩阵的大小是否相等。
- 如果相等，请用户初始化两个矩阵。
- 初始化后，打印两个矩阵。
- 创建一个新矩阵来存储两个矩阵的和
- 调用一个将返回它们总和的方法。
- 遍历这两个矩阵的每个元素，然后将它们相加。
- 将此总和存储在新矩阵中相应的索引处。
- 返回结果矩阵。
- 打印结果矩阵。
- 如果两个矩阵的大小不相等，则打印一条消息重试。
- 停下来。
下面是相同的 Java 语言代码。
/*Java Program to add two matrix*/
import java.util.Scanner;
public class Main
{
// To print a Matrix
static void printMatrix(int M[][],int m,int n)
{
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
System.out.print(M[i][j] + " ");
System.out.println();
}
}
//To add the two matrices and store in matrix c
static int[][] add(int a[][], int b[][], int m,int n)
{
int i, j;
int c[][] = new int[m][m];
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
c[i][j] = a[i][j] + b[i][j];
return c;
}
public static void main(String[] args)
{
int p, q, m, n; //Declare matrix size
Scanner sc = new Scanner(System.in);
System.out.print("Enter the number of rows in the first matrix:");
p = sc.nextInt(); //Initialize first matrix size
System.out.print("Enter the number of columns in the first matrix:");
q = sc.nextInt(); //Initialize the first matrix size
System.out.print("Enter the number of rows in second matrix:");
m = sc.nextInt(); //Initialize second matrix size
System.out.print("Enter the number of columns in the second matrix:");
n = sc.nextInt(); //Initialize the second matrix size
if (p == m && q == n)
{
int a[][] = new int[p][q]; //Declare first matrix
int b[][] = new int[m][n]; //Declare second matrix
//Initialize the first matrix
System.out.println("Enter all the elements of first matrix:");
for (int i = 0; i < p; i++)
{
for (int j = 0; j < q; j++)
{
a[i][j] = sc.nextInt();
}
}
System.out.println("");
//Initialize the second matrix
System.out.println("Enter all the elements of second matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
b[i][j] = sc.nextInt();
}
}
// Print the result
System.out.println("First Matrix:");
printMatrix(a, m, n);
// Print the second matrix
System.out.println("Second Matrix:");
printMatrix(b, m, n);
int c[][] = add(a, b, m,n);
// Print the result
System.out.println("Resultant Matrix:");
printMatrix(c, m, n);
}
else
{
System.out.println("Addition not possible");
System.out.println("Try Again");
}
}
}
输入第一个矩阵的行数:3
输入第一个矩阵的列数:3
输入第二个矩阵的行数:3
输入第二个矩阵的列数:3
输入第一个矩阵的所有元素:6 7 8 5 4 3 2 2 9
输入第二个矩阵的所有元素:9 8 7 6 7 8 9 2
第一个矩阵:
6 7 8
5 4 3
2 2 9
第二矩阵:
9 8 7
6 7 8
9 9 2
合成矩阵:
15 15 15
11 11 11
11 11 11
Java 程序：执行矩阵乘法
原文：https://www.studytonight.com/java-programs/java-program-to-perform-matrix-multiplication
在本教程中，我们将学习如何执行矩阵乘法。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
下面是同样的图示。
输入:
输入第一个矩阵的行数:3
输入第一个矩阵的列数:3
在第二个矩阵中输入行数:3
在第二个矩阵中输入行数:3
输入第一个矩阵的所有元素:1 2 3 4 5 6 7 8 9
输入第二个矩阵的所有元素:9 8 7 6 5 4 3 2 1
输出:
第一个矩阵:
1 2 3
4 5 6
7 8 9
第二个矩阵:
9 8 7
6 5 4
3 2 1
结果矩阵:
30 24 18
84 69 54
138 114 90
程序 1:执行矩阵乘法
在这个程序中，我们将执行矩阵乘法。但是要进行矩阵乘法，第一个矩阵的列数必须等于第二个矩阵的行数。
算法
- 开始
- 声明矩阵大小的变量。
- 初始化第一个矩阵的行数和列数。
- 初始化第二个矩阵的行数和列数。
- 声明两个矩阵。
- 要求用户初始化矩阵。
- 调用一个方法将两个矩阵相乘。
- 打印两个矩阵。
- 检查矩阵乘法是否可能。
- 如果可能，创建一个新的矩阵来存储两个矩阵的乘积。
- 遍历两个矩阵的每一个元素并相乘。
- 将该产品存储在相应索引处的新矩阵中。
- 打印最终产品矩阵。
- 如果矩阵乘法是不可能的，那么显示相同的。
- 停下来。
下面是相同的 Java 语言代码。
/*Java Program to multiply two matrices*/
import java.util.Scanner;
public class Main
{
// To print Matrix
static void printMatrix(int M[][], int rowSize, int colSize)
{
for (int i = 0; i < rowSize; i++)
{
for (int j = 0; j < colSize; j++)
{
System.out.print(M[i][j] + " ");
}
System.out.println();
}
}
// To multiply two matrices a[][] and b[][]
static void multiplyMatrix(int p,int q, int a[][], int m, int n, int b[][])
{
int i, j, k;
// Print the matrices A and B
System.out.println("First Matrix:");
printMatrix(a, p, q);
System.out.println("Second Matrix:");
printMatrix(b, m, n);
// Check if multiplication is Possible
if (m != q)
{
System.out.println("Multiplication Not Possible");
return;
}
// Matrix to store the result
int c[][] = new int[q][n];
// Multiply the two matrices
for (i = 0; i < p; i++)
{
for (j = 0; j < n; j++)
{
for (k = 0; k < m; k++)
c[i][j] += a[i][k] * b[k][j];
}
}
// Print the result
System.out.println("\nResultant Matrix:");
printMatrix(c, p, n);
}
//Driver Code
public static void main(String[] args)
{
int p, q, m, n; //Declare matrix size
Scanner sc = new Scanner(System.in);
System.out.print("Enter the number of rows in the first matrix:");
p = sc.nextInt(); //Initialize first matrix size
System.out.print("Enter the number of columns in the first matrix:");
q = sc.nextInt(); //Initialize first matrix size
System.out.print("Enter the number of rows in the second matrix:");
m = sc.nextInt(); //Initialize second matrix size
System.out.print("Enter the number of columns in the second matrix:");
n = sc.nextInt(); //Initialize second matrix size
int a[][] = new int[p][q]; //Declare first matrix
int b[][] = new int[m][n]; //Declare second matrix
//Initialize the first Matrix
System.out.println("Enter all the elements of first matrix:");
for (int i = 0; i < p; i++)
{
for (int j = 0; j < q; j++)
{
a[i][j] = sc.nextInt();
}
}
System.out.println("");
//Initialize the second matrix
System.out.println("Enter all the elements of second matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
b[i][j] = sc.nextInt();
}
}
//To Multiply two matrices
multiplyMatrix(p ,q, a, m, n, b);
}
}
输入第一个矩阵的行数:3
输入第一个矩阵的列数:3
输入第二个矩阵的行数:3
输入第二个矩阵的列数:3
输入第一个矩阵的所有元素:1 2 3 4 5 6 5 4 3
输入第二个矩阵的所有元素:6 5 4 7 1 2 3 4 5
第一个矩阵:
1 2 3
4 5 6
5 4 3
第二矩阵:
6 5 4
7 1 2
3 4 5
合成矩阵:
29 19 23
77 49 56
67 41 43
程序 2:执行矩阵乘法
在这个程序中，我们将执行矩阵乘法。矩阵乘法是一种简单的二进制运算，它从两个给定的矩阵中产生一个矩阵。当 mn 和 np 阶的两个矩阵相乘时，得到的矩阵将是 m*p 阶。
算法
- 开始
- 声明矩阵大小的变量。
- 初始化第一个矩阵的行数和列数。
- 初始化第二个矩阵的行数和列数。
- 声明两个矩阵。
- 要求用户初始化矩阵。
- 打印两个矩阵。
- 检查矩阵乘法是否可能。
- 如果可能，创建一个新的矩阵来存储两个矩阵的乘积。
- 遍历两个矩阵的每一个元素并相乘。
- 将该产品存储在相应索引处的新矩阵中。
- 打印最终产品矩阵。
- 如果矩阵乘法是不可能的，那么显示相同的。
- 停下来。
下面是相同的 Java 语言代码。
/*Java Program to multiply two matrices*/
import java.util.Scanner;
public class Main
{
//Driver Code
public static void main(String[] args)
{
//Take input from user
Scanner sc = new Scanner(System.in);
int p, q, m, n; //Declare matrix size
System.out.print("Enter the number of rows in the first matrix:");
p = sc.nextInt(); //Initialize the the first matrix size
System.out.print("Enter number of columns in the first matrix:");
q = sc.nextInt(); //Initialize first matrix size
System.out.print("Enter the number of rows in the second matrix:");
m = sc.nextInt(); //Initialize second matrix size
System.out.print("Enter the number of columns in the second matrix:");
n = sc.nextInt(); //Initialize second matrix size
int a[][] = new int[p][q]; //Declare first matrix
int b[][] = new int[m][n]; //Declare second matrix
//Initialize the first Matrix
System.out.println("Enter all the elements of first matrix:");
for (int i = 0; i < p; i++)
{
for (int j = 0; j < q; j++)
{
a[i][j] = sc.nextInt();
}
}
System.out.println("");
//Initialize the second matrix
System.out.println("Enter all the elements of second matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
b[i][j] = sc.nextInt();
}
}
//Print the First Matrix
System.out.println("First Matrix:");
for(int i=0;i<p;i++)
{
for(int j=0;j<q;j++)
{
System.out.print(a[i][j]+" ");
}
System.out.println("");
}
//Print Second Matrix
System.out.println("Second Matrix:");
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
System.out.print(b[i][j]+" ");
}
System.out.println("");
}
// Check if multiplication is Possible
if (m != q) {
System.out.println("Multiplication Not Possible");
return;
}
// Matrix to store the result
int c[][] = new int[q][n];
int k=0;
// Multiply the two matrices
for(int i=0;i<p;i++)
{
for(int j=0;j<n;j++)
{
for (k = 0; k < m; k++)
c[i][j] += a[i][k] * b[k][j];
}
}
// Print the resultant matrix
System.out.println("Resultant Matrix:");
for(int i=0;i<q;i++)
{
for(int j=0;j<n;j++)
{
System.out.print(c[i][j]+" ");
}
System.out.println("");
}
}
}
输入第一个矩阵的行数:3
输入第一个矩阵的列数:3
输入第二个矩阵的行数:3
输入第二个矩阵的列数:3
输入第一个矩阵的所有元素:1 2 3 4 5 6 7 8 9
输入第二个矩阵的所有元素:3 4 5 2 6 7 1 2 1
第一个矩阵:
1 2 3
4 5 6
7 8 9
第二矩阵:
3 4 5
2 6 7
1 2 1
合成矩阵:
10 22 22
28 58 61
46 94 100
Java 程序：成对反转链表
原文：https://www.studytonight.com/java-programs/java-program-to-reverse-a-linked-list-in-pairs
在本教程中，我们将看到如何在 java 中成对反转链表。LinkedList 是一种线性数据结构，其中元素不存储在连续的位置，每个元素都是一个单独的对象，具有数据部分和地址部分。每个元素都被称为一个节点。由于插入和删除的动态性和容易性，它们比数组更受欢迎。但是在继续之前，如果你不熟悉 java 中链表的概念，那么一定要查看一下 Java 中链表上的文章。
输入:输入链表元素:6 7 8 4 5 3
输出:反转链表前:6 7 8 9 5
反向链表后:7 6 9 8 3 5
这可以通过使用以下方法来实现:
方法 1:通过迭代
方法 2:通过递归
让我们看看这些方法中的每一种，以便更好地理解。
Java 程序：程序 1:成对反转链表
在这个程序中，我们将看到如何使用迭代方法在 java 中成对反转链表。
算法:
- 开始
- 声明没有任何初始大小的
Integer类型的链表。 - 使用 add 方法添加元素。
- 将元素追加到列表的末尾。
- 冲销前打印链表元素。
- 首先正确链接两个节点，然后交换这些节点。
- 由于之前的链接断开，现在再次链接节点。
- 反转后打印链表元素。
- 停止
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to Reverse a linked list in Pairs
public class ReverseLinkedListInPair
{
private Node head;
private static class Node
{
private int value;
private Node next;
Node(int value) {
this.value = value;
}
}
public void addLast(Node node) {
if (head == null) {
head = node;
} else {
Node temp = head;
while (temp.next != null)
temp = temp.next;
temp.next = node;
}
}
public void printLinkedList(Node head) {
Node temp = head;
while (temp != null) {
System.out.format("%d ", temp.value);
temp = temp.next;
}
System.out.println();
}
// Reverse the linked list in pair
public static Node reverseLLInPairs(Node head)
{
Node current=head;
Node temp=null;
Node newHead =null;
while (current != null && current.next != null)
{
if (temp != null)
{
temp.next.next = current.next;
}
temp=current.next;
current.next=temp.next;
temp.next=current;
if (newHead == null)
newHead = temp;
current=current.next;
}
return newHead;
}
//Driver Code
public static void main(String[] args) {
ReverseLinkedListInPair li = new ReverseLinkedListInPair();
// Creating a linked list
Node head=new Node(0);
li.addLast(head);
li.addLast(new Node(1));
li.addLast(new Node(2));
li.addLast(new Node(3));
li.addLast(new Node(4));
li.addLast(new Node(5));
System.out.println("Before reversing in pair: ");
li.printLinkedList(head);
//Reversing LinkedList in pairs
Node result=reverseLLInPairs(head);
System.out.println("After reversing in pair: ");
li.printLinkedList(result);
}
}
成对倒车前:
0 1 2 3 4 5
成对倒车后:
1 0 3 2 5 4
Java 程序：程序 2:成对反转链表
在这个程序中，我们将看到如何使用递归方法在 java 中成对反转链表。
算法:
- 开始
- 声明没有任何初始大小的
Integer类型的链表。 - 使用 add 方法添加元素。
- 将元素追加到列表的末尾。
- 冲销前打印链表元素。
- 首先正确链接两个节点，然后调用递归函数来交换元素。
- 由于之前的链接断开，现在再次链接节点。
- 反转后打印链表元素。
- 停止
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to Reverse a linked list in Pairs
public class ReverseLinkedListInPair
{
private Node head;
private static class Node
{
private int value;
private Node next;
Node(int value) {
this.value = value;
}
}
public void addLast(Node node) {
if (head == null) {
head = node;
} else {
Node temp = head;
while (temp.next != null)
temp = temp.next;
temp.next = node;
}
}
public void printLinkedList(Node head) {
Node temp = head;
while (temp != null) {
System.out.format("%d ", temp.value);
temp = temp.next;
}
System.out.println();
}
// Reverse the linked list in pair
public static Node reverseLLInPairs(Node head)
{
if (head == null || head.next == null) {
return head;
}
Node temp=head.next;
head.next=temp.next;
temp.next=head;
head.next=reverseLLInPairs(head.next);
return temp;
}
//Driver Code
public static void main(String[] args) {
ReverseLinkedListInPair li = new ReverseLinkedListInPair();
// Creating a linked list
Node head=new Node(0);
li.addLast(head);
li.addLast(new Node(1));
li.addLast(new Node(2));
li.addLast(new Node(3));
li.addLast(new Node(4));
li.addLast(new Node(5));
System.out.println("Before reversing in pair: ");
li.printLinkedList(head);
//Reversing LinkedList in pairs
Node result=reverseLLInPairs(head);
System.out.println("After reversing in pair: ");
li.printLinkedList(result);
}
}
成对倒车前:
0 1 2 3 4 5
成对倒车后:
1 0 3 2 5 4
Java 程序：如何反转链表
原文：https://www.studytonight.com/java-programs/how-to-reverse-a-linked-list-in-java
在本教程中，我们将看到如何在 java 中反转链表。LinkedList 是一种线性数据结构，其中元素不存储在连续的位置，每个元素都是一个单独的对象，具有数据部分和地址部分。每个元素都被称为一个节点。由于插入和删除的动态性和容易性，它们比数组更受欢迎。但是在继续之前，如果你不熟悉 java 中链表的概念，那么一定要查看一下 Java 中链表上的文章。
输入:输入链表元素:6 7 8 4 5
输出:反转链表前:6 7 8 9 5
反向链表后:5 9 8 7 6
这可以通过使用以下方法来实现:
方法 1:使用内置方法
方法 2:不使用内置方法
让我们看看这些方法中的每一种，以便更好地理解。
Java 程序：程序 1:反向链表
在这个程序中，我们将看到如何使用 collections 类在 java 中反转链表。
算法:
- 开始
- 声明没有任何初始大小的
Integer类型的链表。 - 使用 add 方法添加元素。
- 将元素追加到列表的末尾。
- 冲销前打印链表元素。
- 使用内置的 Collections.reverse()方法来反转链表。
- 反转后打印链表元素。
- 停止
让我们看看下面的例子，以更好地理解上述算法。
// Java program for reversing a linked list using in-built collections class
import java.util.*;
public class Main
{
public static void main(String[] args)
{
// Declaring linkedlist without any initial size
LinkedList<Integer> ll = new LinkedList<Integer>();
// Appending elements at the end of the list
ll.add(new Integer(1));
ll.add(new Integer(2));
ll.add(new Integer(3));
ll.add(new Integer(4));
ll.add(new Integer(5));
System.out.println("The elements of the linked list before reversing: " + ll);
// Collections.reverse method to reverse the list
Collections.reverse(ll);
System.out.println("The elements of the linked list after reversing: " + ll);
}
}
反转前链表的元素:[1，2，3，4，5]
反转后链表的元素:[5，4，3，2，1]
Java 程序：程序 2:反向链表
在这个程序中，我们将看到如何使用任何内置方法在 java 中反转链表。
算法:
- 开始
- 声明没有任何初始大小的
String类型的链表。 - 使用 add 方法添加元素。
- 将元素追加到列表的末尾。
- 冲销前打印链表元素。
- 使用用户定义的函数进行反转。
- 以链表为参数，返回反向链表。
- 循环 n/2 次，其中“n”是链表中的元素数。
- 在第一遍中，交换第一个和第 n 个元素。
- 在第二遍中，交换第二个和第(n-1)个元素，以此类推，直到到达链表的中间。
- 循环终止后返回链表。
- 反转后打印链表元素。
- 停止
让我们看看下面的例子，以更好地理解上述算法。
// Java program to reverse a linked list
import java.util.*;
public class Main
{
public static void main(String[] args)
{
LinkedList<String> ll = new LinkedList<String>();
ll.add(new String("Physics"));
ll.add(new String("Maths"));
ll.add(new String("Java"));
ll.add(new String("English"));
ll.add(new String("Chemistry"));
System.out.println("The elements of the linked list before reversing: " + ll);
// Calling user defined function for reversing
ll = reverseLinkedList(ll);
System.out.println("The elements of the linked list after reversing: " + ll);
}
//Takes a linkedlist as a parameter and returns a reversed linked list
public static LinkedList<String> reverseLinkedList(LinkedList<String> ll)
{
for (int i = 0; i < ll.size() / 2; i++)
{
String temp = ll.get(i);
ll.set(i, ll.get(ll.size() - i - 1));
ll.set(ll.size() - i - 1, temp);
}
// Return the reversed arraylist
return ll;
}
}
反转前链表的元素:【物理、数学、Java、英语、化学】
反转后链表的元素:【化学、英语、Java、数学、物理】
Java 程序：在链表中查找中间元素
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-middle-element-in-a-linked-list
在本教程中，我们将看到如何在 java 中找到链表的中间元素。LinkedList 是一种线性数据结构，其中元素不存储在连续的位置，每个元素都是一个单独的对象，具有数据部分和地址部分。每个元素都被称为一个节点。由于插入和删除的动态性和容易性，它们比数组更受欢迎。但是在继续之前，如果你不熟悉 java 中链表的概念，那么一定要查看一下 Java 中链表上的文章。
输入:输入链表元素:6 7 8 4 5
输出:链表的中间元素是:8
这可以通过使用以下方法来实现:
方法 1:使用 get()方法
方法 2:在单程中找到中间元素
让我们看看这些方法中的每一种，以便更好地理解。
Java 程序：程序 1:在链表中查找中间元素
在这个程序中，我们将看到如何在链表中找到中间元素。
算法:
- 开始
- 使用链表类创建
Integer类型的链表。 - 现在向链表添加元素。
- 首先，使用长度乘 2 公式找到链表的中间索引。
- 使用 get(index)方法查找元素。
- 打印中间元素。
- 停下来。
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to Find the Middle Element in a Linked List
import java.util.LinkedList;
public class Main
{
public static void main(String[] args)
{
// create a linked list using the LinkedList class
LinkedList<Integer> ll = new LinkedList<>();
// Add elements to LinkedList
ll.add(2);
ll.addFirst(3);
ll.addLast(5);
ll.addLast(6);
ll.addLast(8);
ll.addLast(13);
ll.addLast(18);
System.out.println("LinkedList: " + ll);
// access middle element
int middle = ll.get(ll.size()/2);
System.out.println("Middle Element: " + middle);
}
}
链表:[3，2，5，6，8，13，18]
中间元素:6
Java 程序：程序 2:在链表中查找中间元素
在这个程序中，我们将看到如何在链表中找到中间元素。
算法:
- 开始
- 使用链表数据结构创建
String类型的链表。 - 现在向链表添加元素。
- 首先，找到链表的长度。
- 对同一个使用两个指针。
- 第一个指针将在每次迭代中递增，而第二个指针将在第二次迭代中递增。
- 当第一个指针指向链表的末尾时，第二个指针将指向链表的中间元素。
- 打印中间元素。
- 停下来。
让我们看看下面的例子，以更好地理解上述算法。
public class LinkedListTest
{
public static void main(String args[])
{
//creating a LinkedList
LinkedList linkedList = new LinkedList();
LinkedList.Node head = linkedList.head();
linkedList.add( new LinkedList.Node("Apple"));
linkedList.add( new LinkedList.Node("Mango"));
linkedList.add( new LinkedList.Node("Orange"));
linkedList.add( new LinkedList.Node("Gauva"));
linkedList.add( new LinkedList.Node("Litchi"));
//finding middle element of LinkedList in single pass
LinkedList.Node current = head;
int length = 0;
LinkedList.Node middle = head;
while(current.next() != null){
length++;
if(length%2 ==0){
middle = middle.next();
}
current = current.next();
}
if(length%2 == 1){
middle = middle.next();
}
System.out.println("The middle element of the Linked List: "+ middle);
}
}
class LinkedList{
private Node head;
private Node tail;
public LinkedList(){
this.head = new Node("head");
tail = head;
}
public Node head(){
return head;
}
public void add(Node node){
tail.next = node;
tail = node;
}
public static class Node{
private Node next;
private String data;
public Node(String data){
this.data = data;
}
public String data() {
return data;
}
public void setData(String data) {
this.data = data;
}
public Node next() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public String toString(){
return this.data;
}
}
}
链表的中间元素:橙色
Java 程序：按字母顺序排序数组
原文：https://www.studytonight.com/java-programs/java-program-to-sort-an-array-in-alphabetical-order
在本教程中，我们将学习如何按字母顺序对数组元素进行排序。排序是指按字母顺序或数字顺序排列数据。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入: a n m w r t s p
输出: a m n p r s t w
上述问题可以通过以下方式解决:
方法 1:使用比较()
方法 2:使用数组。排序()
方法 3:使用反转命令()
让我们分别看看这些方法。
程序 1:按字母顺序排序数组
在这种方法中，我们将通过将每个元素与其余元素进行比较，按字母顺序对数组进行排序。
算法
- 开始
- 声明数组
- 初始化数组
- 使用两个 for 循环按字母顺序对数组进行排序。
- 使用第一个 for 循环来保存元素。
- 使用第二个 for 循环与其余元素进行比较。
- 使用 compareTo()进行比较。
- 交换数组元素。
- 打印更新后的数组。
- 停止
下面是相同的代码。
下面的程序演示了如何使用compareTo()方法按字母顺序对数组进行排序。
//Java Program to sort an array in alphabetical order.
import java.util.Arrays;
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare the array size
System.out.println("Enter the number of elements ");
n=sc.nextInt(); //Initialize the array size
String fruits[]=new String[n]; //Declare the array
System.out.println("Enter the String ");
Scanner sc1=new Scanner(System.in);
for(int i=0; i<n ;i++) //Initialize the array
{
fruits[i]=sc1.nextLine();
}
//logic for sorting
for(int i = 0; i<n; i++) //Holds each element
{
for (int j = i+1; j<n; j++) //Check for remaining elements
{
//compares each elements of the array to all the remaining elements
if(fruits[i].compareTo(fruits[j])>0)
{
//swapping array elements
String temp = fruits[i];
fruits[i] = fruits[j];
fruits[j] = temp;
}
}
}
//prints the sorted array in alphabetical order
System.out.println(Arrays.toString(fruits));
}
}
输入数组元素个数:10
输入数组元素:
苹果
奶油冻苹果
香蕉
猕猴桃
番石榴
橙子
木瓜
黑莓
红枣
葡萄
【苹果、香蕉、黑莓、奶油冻苹果、红枣、葡萄、番石榴、猕猴桃、橙子、木瓜、】
程序 2:按字母顺序排序数组
在这种方法中，我们将使用 Arrays.sort()方法按字母顺序对数组进行排序。
算法
- 开始
- 声明数组
- 初始化数组
- 调用
Arrays.sort()函数，按字母顺序对数组进行排序。 - 打印排序后的数组。
- 停下来。
下面是相同的代码。
下面的程序演示了如何使用Arrays.sort()方法按字母顺序对数组进行排序。
//Java Program to sort an array in alphabetical order.
import java.util.Arrays;
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
Scanner sc1=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the number of elements ");
n=sc.nextInt(); //Initialize array size
String str[]=new String[n]; //Declare array
System.out.println("Enter the String ");
for(int i=0; i<n ;i++) //Initialize array
{
str[i]=sc1.nextLine();
}
Arrays.sort(str); //Sort the array in alphabetical order
System.out.println(Arrays.toString(str)); //Display the array
}
}
输入元素数量
5
输入字符串
法国
印度
中国
德国
意大利
【中国、法国、德国、印度、意大利】
程序 3:按字母顺序排序数组
在这种方法中，我们将使用Arrays.sort()按字母顺序对数组进行排序，然后再次使用reverseOrder()方法按相反顺序对其进行排序。
算法
- 开始
- 声明数组
- 初始化数组
- 调用
Arrays.sort()函数，按字母顺序对数组进行排序。 - 然后调用
reverseOrder()对数组进行逆序排序。 - 打印排序后的数组。
- 停下来。
下面是相同的代码。
说明:下面的程序演示了如何使用reverseOrder()方法按照相反的字母顺序对数组进行排序。
/*Java Program to sort an array alphabetically in reverse order*/
import java.util.Arrays;
import java.util.Scanner;
import java.util.*;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
Scanner sc1=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the number of elements ");
n=sc.nextInt(); //Initialize array size
String str[]=new String[n]; //Declare array
System.out.println("Enter the String ");
for(int i=0; i<n ;i++) //Initialize array
{
str[i]=sc1.nextLine();
}
Arrays.sort(str,Collections.reverseOrder()); //Sort the array in alphabetical order
System.out.println(Arrays.toString(str)); //Display the array
}
}
输入元素数量
5
输入字符串
孟买
浦那
金奈
兰契
加尔各答
【兰契，浦那，孟买，加尔各答，金奈】
Java 程序：寻找数组中第二大和第二小元素
在本教程中，我们将学习如何在数组中找到第二大和第二小的元素。找到两个最大元素的最简单方法是首先对元素进行排序，然后返回存储在数组第一个和第二个最后一个索引处的元素。但是在继续之前，如果您不熟悉数组的概念，那么一定要查看 Java 中的文章 Arrays。
输入:输入数组元素:7 6 9 2 4 1 3 6 9
输出:第二小= 2
第二大= 7
程序 1:寻找第二大和第二小元素
在这种方法中，我们将直接找到数组中第二大和第二小的元素。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 使用两个 for 循环来显示数组中第二大和第二小的元素。
- 使用第一个 for 循环来保存数组的每个元素
- 使用第二个 for 循环将元素与其余元素进行比较。
- 交换元素以对元素进行排序。
- 显示第二大和第二小的元素。
- 停止
下面是相同的代码。
下面的程序演示了如何找到数组中第二大和第二小的元素。首先，声明一个数组，然后初始化。在两个 for 循环的帮助下，对数组的所有元素进行迭代，然后按降序对元素进行比较和交换。然后分别显示第二大和第二小的元素。
/*Java Program to find the second largest and second smallest elements in the array without using Functions*/
import java.util.Scanner;
public class FindElement
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the size of the array");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the array");
for(int i=0;i<n;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
for(int i=0;i<n;i++) //Use to hold the element
{
for(int j=i+1;j<n;j++) //Use to compare with the rest of the elements
{
if(arr[i]<arr[j]) //Check and swap
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
System.out.println("Second Largest element is "+arr[1]); //Display second largest element.
System.out.println("Second Smallest element is "+arr[n-2]); //Display second smallest element.
}
}
输入数组 10 的大小
输入数组 56 7 6 45 3 4 23 12 21 1
第二大元素是 45
第二小元素是 3
程序 2:寻找第二大和第二小元素
在这种方法中，我们将使用单独的方法，使用 Arrays.sort().找到数组中第二小和第二大的元素
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 调用将显示数组中第二大和第二小元素的方法。
- 使用
Arrays.sort()对数组进行排序。 - 在第一个和第二个最后索引处显示元素。
- 这是第二大第二小的元素。
- 停止
下面是相同的代码。
下面的程序演示了如何使用单独的方法，通过Arrays.sort()找到数组中第二大和第二小的元素。首先，声明一个数组，然后初始化。接下来调用一个方法。使用Arrays.sort()对数组进行排序，显示第一个和第二个最后的元素，分别是第二小和第二大元素。
/*Java Program to find the second largest and second smallest elements in the array using Functions*/
import java.util.Scanner;
import java.util.*;
public class findElement
{
static void findLargest(int arr[], int n) //Method to find the second largest and second smallest element
{
Arrays.sort(arr); //Sorts the array in ascending order
System.out.println("Second Largest element is "+arr[n-2]); //Display Second Smallest
System.out.println("Second Smallest element is "+arr[1]); //Display Second Largest
}
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the size of the array");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the array");
for(int i=0;i<n;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
findLargest(arr,n); //Function Call
}
}
输入数组 10 的大小
输入数组 8 7 9 5 4 3 8 6 1 2
第二大元素是 8
第二小元素是 2
Java 程序：寻找数组中最大元素
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-largest-element-in-an-array
在本教程中，我们将学习如何找到数组中最大的元素。找到两个最大元素的最简单方法是首先对元素进行排序，然后返回存储在第 0 个索引处的元素。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入数组元素:7 6 9 2 4 1 3 6 9
输出:最大= 9
程序 1:寻找数组中最大的元素
在这种方法中，我们将直接在主方法本身中找到最大的元素。首先，我们将按降序对元素进行排序，然后返回存储在第 0 个索引中的元素。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 使用两个 for 循环来显示数组中最大的元素。
- 使用第一个 for 循环来保存数组的每个元素
- 使用第二个 for 循环将元素与其余元素进行比较。
- 交换元素以对元素进行排序。
- 显示最大的元素。
- 停止
下面是相同的代码。
下面的程序演示了如何直接找到数组中最大的元素。首先，声明一个数组，然后初始化。在两个 for 循环的帮助下，对数组的所有元素进行迭代，然后按降序对元素进行比较和交换。然后显示数组中最大的元素。
/*Java Program to find the largest element in an array without using Functions*/
import java.util.Scanner;
public class findElement
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the size of the array");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the array");
for(int i=0;i<n;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
for(int i=0;i<n;i++) //Use to hold an element
{
for(int j=i+1;j<n;j++) //Use to check for rest of the elements
{
if(arr[i]<arr[j]) //Compare and swap
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
System.out.println("Largest element is "+arr[0]); //Display Largest
}
}
输入数组 10 的大小
输入数组 87 6 7 5 4 3 4 32 12 1
最大的元素是 87
程序 2:寻找数组中最大的元素
在这种方法中，我们将使用单独的方法，使用Arrays.sort()找到数组中最大的元素。Arrays.sort()存在于 java.util 包中。Arrays类在被调用时自动对数组进行排序。它减少了用户的工作，因为用户不必编写不同的代码来对数组进行排序。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 调用将显示数组中最大元素的方法。
- 使用
Arrays.sort()首先对数组的元素进行排序。 - 最后一个元素是数组中最大的元素。
- 显示最后一个元素。
- 停止
下面是相同的代码。
下面的程序演示了如何使用单独的方法来查找数组中最大的元素。首先，声明一个数组，然后初始化。接下来调用一个方法。然后使用Arrays.sort()对数组进行排序，显示最后一个索引元素，即数组中显示最大的元素。
/*Java Program to find the largest element in an array using Arrays.sort()*/
import java.util.Scanner;
import java .io.*;
import java .util.*;
public class findElement
{
static void findLargest(int arr[], int n) //Method to display the largest element
{
Arrays.sort(arr); //Sort the array
System.out.println("Largest element is "+arr[n-1]); //Display Largest Element
}
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the size of the array");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the array");
for(int i=0;i<n;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
findLargest(arr,n);
}
}
输入数组 10 的大小
输入数组 56 7 6 45 3 4 23 12 21 1
最大的元素是 56
Java 程序：将一个数组的偶数和奇数元素放入两个独立的数组中
在本教程中，我们将学习如何将偶数和奇数元素放在两个独立的数组中。最简单的方法是首先通过分别计算数组中偶数和奇数项的数量来检查两个数组的索引，然后将这些元素粘贴到新形成的数组中。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入数组元素:7 6 9 2 4 1 3 6 9 8
输出:
偶数数组:6 2 4 6 8
奇数数组:7 9 1 3 9
程序 1:把偶数和奇数柠檬放在两个独立的数组中
在这种方法中，我们将直接将数组的偶数和奇数元素放在主方法本身的两个独立数组中。
算法
1.开始
2.声明一个数组。
3.初始化数组。
4.声明两个变量来存储偶数组和奇数组的大小，并将其初始化为零。
5.计算偶数和奇数元素的总数，并将其分配给数组大小。
6.声明两个新数组来存储偶数和奇数元素。
7.使用 for 循环迭代所有元素
8.如果元素是偶数，则将其存储在第一个数组中，如果元素是奇数，则将其存储在第二个数组中。
9.显示两个数组。
10.停下来。
下面是相同的代码。
程序 2:将偶数和奇数元素放入两个独立数组的示例
下面的程序演示了如何将偶数和奇数元素直接放在两个独立的数组中。首先，声明一个数组，然后初始化。然后计算偶数和奇数元素的数量。声明两个具有这些大小的新数组，并将偶数和奇数元素复制到这些数组中。最后，打印这两个独立的数组。
/*Java Program to put the even and odd elements in two separate array*/
import java.util.Scanner;
public class findElement
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the size of the array");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the array");
for(int i=0;i<n;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
int m=0,n1=0; //Declare the size of the array for even and odd elements
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
m++; //Increment even array size
else
n1++; //Increment odd array size
}
int even[]=new int[m]; //Declare an even array
int odd[]=new int[n1]; //Declare an odd array
int k=0,t=0;
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
{
even[k]=arr[i]; //Initialize elements of even array
k++;
}
else
{
odd[t]=arr[i]; //Initialize elements of odd array
t++;
}
}
System.out.println("The array with even elements...");
for(int i=0;i<m;i++)
{
System.out.print(even[i]+" "); //Print Even Array
}
System.out.println("");
System.out.println("The array with odd elements...");
for(int i=0;i<n1;i++)
{
System.out.print(odd[i]+" "); //Print Odd Array
}
}
}
输入数组 10 的大小
输入数组 87 6 7 5 4 3 4 32 12 1
偶数元素的数组...
6 4 32 12
奇数元素的数组...
87 7 5 3 1
程序 2:把偶数和奇数柠檬放在两个独立的数组中
在这种方法中，我们将使用一种方法将数组的偶数和奇数元素放在两个独立的数组中，并使用另一种方法打印这些元素。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 调用一个方法，将数组的偶数和奇数元素放在两个独立的数组中。
- 在其中声明两个变量来存储偶数和奇数数组的大小，并将它们初始化为零。
- 计算偶数和奇数元素的总数，并将其分配给数组大小。
- 声明两个新数组来存储偶数和奇数元素。
- 使用 for 循环迭代所有元素
- 如果元素是偶数，则将其存储在第一个数组中，如果元素是奇数，则将其存储在第二个数组中。
- 调用另一个方法来打印这两个数组。
- 停止
下面是相同的代码。
下面的程序演示了如何使用不同的方法将偶数和奇数元素放在两个独立的数组中。首先，声明一个数组，然后初始化。然后调用一个方法，计算偶数和奇数元素的数量。声明两个具有这些大小的新数组，并将偶数和奇数元素复制到这些数组中。然后调用另一个方法来打印这些数组。
/*Java Program to put the even and odd elements in two separate arrays*/
import java.util.Scanner;
public class findElement
{
//Method to print the even and odd array
static void printArray(int even[], int m, int odd[],int n1)
{
System.out.println("The array with even elements...");
for(int i=0;i<m;i++)
{
System.out.print(even[i]+" "); //Print Even Array
}
System.out.println("");
System.out.println("The array with odd elements...");
for(int i=0;i<n1;i++)
{
System.out.print(odd[i]+" "); //Print Odd Array
}
}
//Method to put even and odd elements in different arrays
static void separate(int arr[],int n)
{
int m=0,n1=0; //Declare the size of the array for even and odd elements
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
m++; //Increment even array size
else
n1++; //Increment odd array size
}
int even[]=new int[m]; //Declare an even array
int odd[]=new int[n1]; //Declare an odd array
int k=0,t=0;
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
{
even[k]=arr[i]; //Initialize elements of even array
k++;
}
else
{
odd[t]=arr[i]; //Initialize elements of odd array
t++;
}
}
printArray(even,m,odd,n1);
}
//Driver Method
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the size of the array");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the array");
for(int i=0;i<n;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
separate(arr,n);
}
}
输入数组的大小 10
输入数组 78 65 43 45 3 21 78 88 24 12
偶数元素的数组...
78 78 88 24 12
奇元阵...
65 43 45 3 21
Java 程序：在数组的指定位置插入一个元素
在本教程中，我们将学习如何将元素添加到数组中的给定位置。最简单的方法是移动元素，然后在特定位置插入元素。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:
原始数组:5 7 2 3 1 5 6 8
要素:55
职位:2
产量:5 7 55 2 3 5 6 8
程序 1:在数组的给定位置添加一个元素
在这种方法中，我们将使用循环在特定位置插入元素。
算法
- 开始
- 声明数组
- 初始化数组。
- 声明要插入的元素和插入位置。
- 声明一个大小为+1 的新数组。
- 使用 for 循环遍历每个元素。
- 首先将所有元素插入到该位置。
- 然后，在特定位置插入元素。
- 插入其余的元素。
- 返回新数组。
- 打印更新后的数组。
- 停下来。
下面是相同的代码。
下面的程序演示了如何使用循环在数组的特定位置添加元素。
/*Java Program to add an element in an Array at a specific position*/
import java.util.Arrays;
import java.util.Scanner;
public class Main
{
//Method to add an element in the given specific position
public static int[] addElement(int n, int arr[], int ele, int pos)
{
int i;
// create a new array of size n+1
int newarr[] = new int[n + 1];
// insert the elements from the old array into the new array
for (i = 0; i < n + 1; i++)
{
if (i < pos - 1)
newarr[i] = arr[i]; // insert all elements till position
else if (i == pos - 1)
newarr[i] = ele; // then insert element at specific position
else
newarr[i] = arr[i - 1]; // then insert rest of the elements
}
return newarr;
}
//Driver Method
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n; //Array Size Declaration
System.out.println("Enter the number of elements :");
n=sc.nextInt(); //Array Size Initialization
int arr[]=new int[n]; //Array Declaration
System.out.println("Enter the elements of the array :");
for(int i=0;i<n;i++) //Array Initialization
{
arr[i]=sc.nextInt();
}
System.out.println("Enter the elements you want to insert :");
int ele = sc.nextInt();
// Position to insert
System.out.println("Enter the position where you want to insert :");
int pos = sc.nextInt();
arr = addElement(n, arr, ele, pos);
// print the updated array
System.out.println("\nArray with " + ele + " inserted at position " + pos + ":\n" + Arrays.toString(arr));
}
}
输入元素个数:10
输入数组元素:8 7 6 9 5 3 4 1 2 9
输入要插入的元素:22
输入要插入的位置:2
在位置 2 插入 22 的数组:
【8，22，7，6，9，5，3，4，1，2，9】
程序 2:在数组的给定位置添加一个元素
在这种方法中，我们将数组转换为ArrayList，以便在特定位置插入元素。
算法
- 开始
- 声明数组
- 初始化数组。
- 声明要插入的元素和插入位置。
- 声明将插入元素的单独方法。
- 将数组转换为
ArrayList。 - 在该位置添加元素。
- 将列表转换回数组。
- 现在，打印原始数组。
- 显示更新的数组。
- 停下来。
下面是相同的代码。
下面的程序演示了如何使用ArrayList在数组的特定位置添加元素。
/*Java Program to add an element in an Array at a specific position*/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.Collections;
public class Main
{
//Method to add an element in the given specific position
private static void addElement(Integer[] arr, int element, int position)
{
// Coverting array to ArrayList
List<Integer> list = new ArrayList<>(Arrays.asList(arr));
// Adding the element at position
list.add(position - 1, element);
// Converting the list back to array
arr = list.toArray(arr);
// Printing the original array
System.out.println("Initial Array:\n" + Arrays.toString(arr));
// Printing the updated array
System.out.println("\nArray with " + element + " inserted at position "+ position + ":\n" + Arrays.toString(arr));
}
//Driver Method
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n; //Array Size Declaration
System.out.println("Enter the number of elements :");
n=sc.nextInt(); //Array Size Initialization
Integer arr[]=new Integer[n]; //Array Declaration
System.out.println("Enter the elements of the array :");
for(int i=0;i<n;i++) //Array Initialization
{
arr[i]=sc.nextInt();
}
System.out.println("Enter the elements you want to insert :");
int ele = sc.nextInt();
// Position to insert
System.out.println("Enter the position where you want to insert :");
int pos = sc.nextInt();
// Calling the function to insert
addElement(arr, ele, pos);
}
}
输入元素个数:
10
输入数组元素:
4 5 3 6 8 9 1 2 7 6
输入要插入的元素:
21
输入要插入的位置:
2
初始数组:
【4，5，3，6，8，9，1，2，7，6】
在位置 2 插入 21 的数组:
【4，21
Java 程序：从数组中删除指定整数
在本教程中，我们将学习如何从数组中删除特定元素。移除数组中元素的最简单方法是将元素从我们要移除元素的位置向左移动一个索引。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入: 5 9 8 3 2 6 7
输出:待删除元素:8
数组:5 9 3 2 6 7
程序 1:如何从数组中删除特定元素
在这种方法中，我们将遍历所有元素，并将元素向左移动 1 个索引，只要找到要删除的元素。
算法
- 开始
- 声明数组
- 初始化数组。
- 声明要删除的元素。
- 使用 for 循环迭代数组的所有元素。
- 如果找到该元素，则开始将该索引后的元素向左移动一个元素。
- 现在，打印更新后的数组。
- 停止
下面是相同的代码。
下面的程序演示了如何通过遍历所有元素从数组中删除特定元素。
/*Java Program to delete an element from an Array*/
import java.util.Arrays;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n; //Array Size Declaration
System.out.println("Enter the number of elements :");
n=sc.nextInt(); //Array Size Initialization
Integer arr[]=new Integer[n]; //Array Declaration
System.out.println("Enter the elements of the array :");
for(int i=0;i<n;i++) //Array Initialization
{
arr[i]=sc.nextInt();
}
System.out.println("Enter the element you want to remove ");
int elem = sc.nextInt();
for(int i = 0; i < arr.length; i++)
{
if(arr[i] == elem) //If element found
{
// shifting elements
for(int j = i; j < arr.length - 1; j++)
{
arr[j] = arr[j+1];
}
break;
}
}
System.out.println("Elements after deletion " );
for(int i = 0; i < arr.length-1; i++)
{
System.out.print(arr[i]+ " ");
}
}
}
输入元素个数:10
输入数组元素:
1 2 3 4 5 6 7 8 9 10
输入要删除的元素
5
删除后的元素
1 2 3 4 6 7 8 9 10
程序 2:如何从数组中删除特定元素
在这种方法中，我们将使用集合 API 从数组中移除元素。首先，我们将一个数组转换成一个ArrayList，然后删除特定的元素。移除元素后，我们将把ArrayList转换回数组。
算法
- 开始
- 声明数组
- 初始化数组。
- 声明要删除的元素。
- 使用 for 循环迭代数组的所有元素。
- 如果找到该元素，则调用一个单独的方法来删除该元素。
- 将数组转换为
ArrayList。 - 现在，移除元素。
- 将其转换回数组。
- 现在，打印更新后的数组。
- 停下来。
下面是相同的代码。
下面的程序演示了如何使用 Java 语言提供的集合 API 从数组中删除特定的元素。
/*Java Program to delete an element in an Array*/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class RemoveElement
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int n; // Array Size Declaration
System.out.println("Enter the number of elements :");
n=in.nextInt(); // Array Size Initialization
Integer arr[]=new Integer[n]; // Array Declaration
System.out.println("Enter the elements of the array :");
for(int i=0;i<n;i++) // Array Initialization
{
arr[i]=in.nextInt();
}
System.out.print("Enter Element to be deleted : ");
int elem = in.nextInt(); //Initializing Element
System.out.println("Original Array " + Arrays.toString(arr));
for(int i = 0; i < arr.length; i++)
{
if(arr[i] == elem)
{
arr = removeElementUsingCollection(arr, i);
break;
}
}
System.out.println("Array after removal of Element -- " );
for(int i = 0; i < arr.length; i++)
{
System.out.print(" " + arr[i]);
}
}
static Integer[] removeElementUsingCollection( Integer[] arr, int index )
{
List<Integer> tempList = new ArrayList<Integer>(Arrays.asList(arr));
tempList.remove(index);
return tempList.toArray(new Integer[0]);
}
}
输入元素个数:10
输入数组元素:
1 2 3 4 5 6 7 8 9 10
输入要删除的元素:8
原数组
【1，2，3，4，5，6，7，8，9，10】
删除元素后的数组-
1 2 3 5 6 7 9 10
Java 程序：按升序排序数组
原文：https://www.studytonight.com/java-programs/java-program-to-sort-an-array-in-ascending-order
在本教程中，我们将学习如何按升序对数组元素进行排序。排序是指按字母顺序或数字顺序排列数据。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入数组元素:5 4 6 7 8 2 3 1 9
输出:按升序排列的数组:1 2 3 4 5 6 7 8 9
方法 1:使用循环
方法 2:使用数组。排序()
让我们分别看看这些方法。
程序 1:按升序排序数组的元素
在这种方法中，我们将看到如何使用循环以升序对数组进行排序。我们可以使用手动排序对数组进行排序，就像使用 for 循环一样。我们可以做的是使用两个 for 循环，一个从开始遍历数组，另一个 for 循环在外部遍历下一个元素。在正文中，我们可以比较相邻的元素，如果它们没有按顺序排列，就可以交换。我们也可以使用一个临时变量来交换元素。
算法
- 开始
- 声明数组
- 要求用户初始化数组
- 声明一个临时变量来存储交换时的元素。
- 对同一个循环使用两个。
- 使用第一个 for 循环来保存元素并遍历所有元素。
- 使用第二个 for 循环与其余元素进行比较。
- 通过比较和交换对元素进行排序。
- 显示更新的数组。
- 停止
下面是相同的代码。
下面的程序演示了如何使用循环对数组进行升序排序。
/*Java Program to Sort an Array in Ascending Order*/
import java.util.Arrays;
import java.util.Scanner;
import java.util.Collections;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n; //Array Size Declaration
System.out.println("Enter the number of elements :");
n=sc.nextInt(); //Array Size Initialization
Integer arr[]=new Integer[n]; //Array Declaration
System.out.println("Enter the elements of the array :");
for(int i=0;i<n;i++) //Array Initialization
{
arr[i]=sc.nextInt();
}
int temp = 0; //Temporary variable to store the element
for (int i = 0; i < arr.length; i++) //Holds each Array element
{
for (int j = i+1; j < arr.length; j++) //compares with remaining Array elements
{
if(arr[i] > arr[j]) //Compare and swap
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println();
//Displaying elements of array after sorting
System.out.println("Elements of array sorted in ascending order: ");
for (int i = 0; i < arr.length; i++)
{
System.out.print(arr[i] + " ");
}
}
}
输入元素个数:10
输入数组元素:
6 7 8 4 3 5 1 8 9 7
数组元素按升序排序:
1 3 4 5 6 7 8 8 9
程序 2:按升序排序数组的元素
在这种方法中，我们将看到如何使用 Arrays.sort()以升序对数组进行排序。“java.util”包的 Arrays 类提供了排序方法，该方法以数组作为参数，并对数组进行排序。这是一种直接排序方法，只需调用一次方法，就可以按升序对数组进行排序。
算法:
- 开始
- 声明数组
- 要求用户初始化数组
- 使用 Arrays.sort()以升序对元素进行排序。
- 打印更新后的数组。
- 停止
下面是相同的代码。
下面的程序演示了如何使用 Arrays.sort()按升序对数组进行排序。
/*Java Program to Sort an Array in Ascending Order*/
import java.util.Arrays;
import java.util.Scanner;
public class AscendingOrder
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n; //Array Size Declaration
System.out.println("Enter the number of elements :");
n=sc.nextInt(); //Array Size Initialization
int arr[]=new int[n]; //Array Declaration
System.out.println("Enter the elements of the array :");
for(int i=0;i<n;i++) //Array Initialization
{
arr[i]=sc.nextInt();
}
Arrays.sort(arr); //Sorts the Array in Ascending Order
System.out.printf("Sorted arr[] : %s",
Arrays.toString(arr)); //Prints the sorted Array
}
}
输入元素个数:10
输入数组元素:1 4 2 5 6 8 2 3 9 8
排序 arr[] : [1，2，2，3，4，5，6，8，8，9]
Java 程序：按降序排序数组
原文：https://www.studytonight.com/java-programs/java-program-to-sort-an-array-in-descending-order
在本教程中，我们将学习如何按降序对数组元素进行排序。排序是指按字母顺序或数字顺序排列数据。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入: 5 4 6 7 8 2 3 1 9
输出:9 8 7 6 5 3 2 1
程序 1:按降序排序数组的元素
在这种方法中，我们将看到如何使用循环按降序对数组进行排序。我们可以使用手动排序对数组进行排序，就像使用 for 循环一样。我们可以做的是使用两个 for 循环，一个从开始遍历数组，另一个 for 循环在外部遍历下一个元素。在正文中，我们可以比较相邻的元素，如果它们没有按顺序排列，就可以交换。我们也可以使用一个临时变量来交换元素。
算法
- 开始
- 声明数组
- 初始化数组
- 声明一个临时变量来存储交换时的元素。
- 对同一个循环使用两个。
- 使用第一个 for 循环来保存元素并遍历所有元素。
- 使用第二个 for 循环与其余元素进行比较。
- 通过比较和交换对元素进行排序。
- 显示更新的数组。
- 停止
下面是相同的代码。
下面的程序演示了如何使用循环对数组进行降序排序。
/*Java Program to Sort an Array in Descending Order*/
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n; //Array Size Declaration
System.out.println("Enter the number of elements :");
n=sc.nextInt(); //Array Size Initialization
Integer arr[]=new Integer[n]; //Array Declaration
System.out.println("Enter the elements of the array :");
for(int i=0;i<n;i++) //Array Initialization
{
arr[i]=sc.nextInt();
}
int temp = 0; //Temporary variable to store the element
for (int i = 0; i < arr.length; i++) //Holds each Array element
{
for (int j = i+1; j < arr.length; j++) //compares with remaining Array elements
{
if(arr[i] < arr[j]) //Compare and swap
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println();
//Displaying elements of array after sorting
System.out.println("Elements of array sorted in descending order: ");
for (int i = 0; i < arr.length; i++)
{
System.out.print(arr[i] + " ");
}
}
}
输入元素个数:10
输入数组元素:6 7 4 51 2 3 9 77 8 4
数组元素按降序排序:
77 51 9 8 7 6 4 3 2
程序 2:按降序排序数组的元素
在这种方法中，我们将看到如何使用 Arrays.sort()和 Collections.reverseOrder()按降序对数组进行排序。“java.util”包的 Arrays 类提供了排序方法，该方法以数组作为参数，并对数组进行排序。这是一种直接排序方法，只需调用一次方法，就可以按升序对数组进行排序。然后，当使用 Collections.reverseOrder()时，它会反转数组的顺序，现在得到的数组是降序的。
算法
- 开始
- 声明数组
- 初始化数组
- 使用
Arrays.sort()对元素进行升序排序。 - 然后，使用 Collections.reverseOrder()反转顺序。
- 更新后的数组将按降序排列。
- 打印更新后的数组。
- 停止
下面是相同的代码。
这里需要注意的一点是 Collections.reverseOrder()不适用于基元类型。因此，我们将定义一个整数数组。
下面的程序演示了如何使用Arrays.sort()和Collections.reverseOrder()对数组进行降序排序
/*Java Program to Sort an Array in Descending Order*/
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Collections.reverseOrder do not work for primitive Types
//define an array with Integer
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of elements ");
Integer n=sc.nextInt();
System.out.println("Enter the array elements ");
Integer[] arr=new Integer[n];
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt();
}
//print original array
System.out.printf("Original Array: %s",
Arrays.toString(arr));
// Sorts the array in descending order
Arrays.sort(arr, Collections.reverseOrder());
//print sorted array
System.out.printf("\n\nSorted Array: %s",
Arrays.toString(arr));
}
}
输入元素个数 10
输入数组元素 6 7 4 51 2 3 9 77 8 4
原始数组:[6，7，4，51，2，3，9，77，8，4]
排序数组:[77，51，9，8，7，6，4，4，3，2]
Java 程序：计算数组的和与均值
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-sum-and-average-of-an-array
在本教程中，我们将学习如何计算数组中所有元素的总和和平均值。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入数组元素:1 2 3 4 5 6 7 8 9 10
输出:总和= 55
平均值= 5.5
程序 1:计算一个数组中所有元素的总和和平均值
在这种方法中，我们将使用迭代法来计算数组中所有元素的总和和平均值。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 调用一个方法来计算数组中所有元素的总和和平均值。
- 在那里声明一个 sum 变量，并将其初始化为 0。
- 在每次迭代中更新总和。
- 打印总和。
- 计算平均值并返回。
- 打印平均值。
- 停下来。
下面是相同的代码。
下面的程序演示了如何使用迭代法计算数组的和与平均值。
//Java program to calculate the average of array elements
import java.util.Scanner;
public class Main
{
// Function that returns the average of an array.
static double averageCalculate(int a[], int n)
{
// Find sum of array element
int sum = 0;
for (int i = 0; i < n; i++)
{
sum += a[i];
}
System.out.println("The total sum of all the elements in the array is "+sum);
return (double)sum / n;
}
//driver code
public static void main (String[] args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements in the array ");
n=sc.nextInt(); //Initialize the array size
int arr[] = new int[n]; //Declare array
System.out.println("Enter the array elements ");
for(int i=0;i<n;i++) //Initialize the array
{
arr[i]=sc.nextInt();
}
System.out.println("The average of all the elements in an array is "+averageCalculate(arr, n));
}
}
输入数组中元素的总数 10
输入数组元素 1 2 3 4 5 6 7 8 9 10
数组中所有元素的总和为 55
数组中所有元素的平均值为 5.5
程序 2:计算一个数组中所有元素的总和和平均值
在这种方法中，我们将使用递归方法来计算数组中所有元素的总和和平均值。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 调用一个方法来计算数组中所有元素的总和和平均值。
- 使用递归函数计算数组中所有元素的总和和平均值。
- 返回数组中所有元素的平均值和总和。
- 打印数组中所有元素的平均值和总和。
- 停止
下面是相同的代码。
下面的程序演示了如何使用递归函数计算数组的和与平均。
//Java program to calculate the average of array elements using recursive function
import java.util.Scanner;
public class Main
{
// Recursively computes average of a[]
static double avgCalcRec(int a[], int i, int n)
{
// Last element
if (i == n-1)
return a[i];
// When index is 0, divide sum computed so
// far by n.
if (i == 0)
return ((a[i] + avgCalcRec(a, i+1, n))/n);
// Compute sum
return (a[i] + avgCalcRec(a, i+1, n));
}
// Function that returns the average of an array.
static double averageCalculate(int a[], int n)
{
return avgCalcRec(a, 0, n);
}
//driver code
public static void main (String[] args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements in the array ");
n=sc.nextInt(); //Initialize the array size
int arr[] = new int[n]; //Declare array
System.out.println("Enter the array elements ");
for(int i=0;i<n;i++) //Initialize the array
{
arr[i]=sc.nextInt();
}
//Print the average
double avg=averageCalculate(arr, n);
System.out.println("The average of all the elements in an array is "+avg);
//Print the sum
double sum=avg*n;
System.out.println("The sum of all the elements in an array is "+sum);
}
}
输入数组中元素的总数 10
输入数组元素 32 1 4 42 56 78 96 23 13 31
数组中所有元素的平均值为 37.6
数组中所有元素的总和为 376.0
Java 程序：寻找给定数组中最大的两个数字
在本教程中，我们将学习如何找到数组中最大的两个元素。找到两个最大元素的最简单方法是首先对元素进行排序，然后返回存储在第 0 个和第一个索引中的元素。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入数组元素:7 6 9 2 4 1 3 6 9
输出:第一大= 9
第二大= 7
程序 1:寻找数组中最大的两个元素
在这种方法中，我们将在主方法本身中直接找到数组中最大和第二大的元素。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 在同一个主方法中，检查最大和第二大元素。
- 声明两个最大的变量，并用数组的第一个和第二个元素初始化它们。
- 然后通过交换和比较，我们找到最大和第二大元素。
- 我们再次检查元素以避免重复元素。
- 显示结果。
- 停止
下面是相同的代码。
下面的程序演示了如何在不使用函数的情况下找到数组中最大的两个数字。在这个程序中，我们首先声明并初始化数组。然后在主方法本身中，我们声明两个变量，并将前两个元素指定为最大和第二大元素。然后，通过交换和比较，我们找到元素并显示输出。
/*Java Program to directly find the two largest elements in an array*/
import java.util.Scanner;
public class LargestElement
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the size of the array");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the array");
for(int i=0;i<n;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
int lar1=arr[0]; //Initialize the first largest element
int lar2=arr[1]; //Initialize the second largest element
//Check by swapping elements
if(lar1<lar2)
{
int temp=lar1;
lar1=lar2;
lar2=temp;
}
for(int i=2;i<n;i++)
{
if (arr[i] > lar1)
{
lar2 = lar1;
lar1 = arr[i];
}
else if (arr[i] > lar2 && arr[i] != lar1)
{
lar2 = arr[i];
}
}
System.out.println("First Largest"+lar1); //Display the first largest
System.out.println("Second Largest "+lar2); //Display the second largest
}
}
输入数组 7 的大小
输入数组 1 5 6 2 3 4 6 6
第一大 6
第二大 5
程序 2:寻找数组中最大的两个元素
在这种方法中，我们将使用单独的方法，使用Arrays.sort()方法找到数组中最大和第二大的元素。
算法
- 开始
- 声明一个数组。
- 初始化数组。
- 调用一个单独的方法，该方法将显示数组中最大的前两个元素。
- 声明两个最大的变量，并用数组的第一个和第二个元素初始化它们。
- 然后通过使用
Array.sort()首先对数组的元素进行排序。 - 检查最大和第二大元素。
- 再次检查重复的元素。
- 显示结果。
- 停止
下面是相同的代码。
下面的程序演示了如何使用不同的方法找到数组中最大的两个数字。在这个程序中，我们首先声明并初始化数组。然后我们调用一个方法，声明两个变量，并将前两个元素指定为最大和第二大元素。然后，通过使用Arrays.sort()首先对数组进行排序，然后找到两个最大的元素并显示输出。
/*Java Program to find the two largest elements in an array using separate methods*/
import java.util.Scanner;
import java.util.*;
public class LargestElement
{
static void findLargest(int arr[], int n) //Method to find the two largest element
{
int lar1=arr[0]; //Initialize the first largest
int lar2=arr[1]; //Initialize the second largest
//Sort the elements of the array using Array.sort()
Arrays.sort(arr);
for(int i=2;i<n;i++)
{
if (arr[i] > lar1)
{
lar2 = lar1;
lar1 = arr[i];
}
else if (arr[i] > lar2 && arr[i] != lar1)
{
lar2 = arr[i];
}
}
System.out.println("First Largest"+lar1); //Display First Largest
System.out.println("Second Largest "+lar2); //Display Second Largest
}
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the size of the array");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the array");
for(int i=0;i<n;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
findLargest(arr,n);
}
}
输入数组 10 的大小
输入数组 4 6 1 2 3 98 6 2 98 1 2
第一大 98
第二大 12
Java 程序：循环置换数组元素
在本教程中，我们将学习如何循环置换数组的元素，也就是说，将每个数组元素向左移动一个索引。第一个值将进入最后一个索引。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入: 2 4 1 5 6 7
输出: 4 1 5 6 7 2
程序 1:循环置换数组的元素
在这种方法中，我们通过将元素移动一个位置来循环置换数组的元素。
算法
- 开始
- 声明一个数组。
- 初始化数组
- 声明一个变量，该变量将在循环前的第一个索引处存储元素。
- 使用 for 循环迭代数组的每个元素。
- 现在，将每个元素向左移动。
- 现在，修改后的数组中的最后一个元素将是起始元素。
- 停止
下面的程序演示了如何通过遍历和移位元素来循环置换数组的元素。在 for 循环之前声明一个变量来存储数组的第一个元素。使用 for 循环将其余元素向左移动一个位置。最后，将存储的值赋给数组的最后一个元素。显示结果。
/*Java program to cyclically permute the elements of an array*/
import java.util.Arrays;
import java.util.Scanner;
import java.util.*;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
System.out.println("Initial Array "+Arrays.toString(arr));
int x = arr[0]; // store a[0]
int i;
for (i = 0; i < arr.length - 1; i++) {
// for other element shift left
arr[i] = arr[i + 1];
}
// for the last element in the modified array
// it will be starting element
arr[i] = x;
System.out.println("Updated Array" +Arrays.toString(arr)); //Display the array
}
}
输入元素数量:
5
输入数组元素
6 7 8 2 3 4
初始数组【6 7 8 2 3 4】
更新数组【7 8 2 3 4 6】
程序 2:循环置换数组的元素
在这种方法中，我们通过交换元素来循环置换数组的元素。
算法
- 开始
- 声明一个数组。
- 初始化数组
- 声明另一个变量来存储数组的第一个元素。
- 使用 for 循环来交换数组的每个元素。
- 在每次迭代中，用第一个元素交换每个元素。
- 在每次迭代中继续交换元素，直到循环结束。
- 显示更新的数组。
- 停下来。
下面是相同的代码。
下面的程序演示了如何通过交换元素来循环置换数组的元素。首先，声明并初始化一个数组。声明另一个变量来存储数组的第一个元素。使用 for 循环遍历数组的每个元素。然后，用数组的第一个元素交换每个元素。在每次迭代中，只有两个元素被交换。继续这个过程，直到循环结束，得到最终结果。
/*Java program to cyclically permute the elements of an array*/
import java.util.Arrays;
import java.util.Scanner;
import java.util.*;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
//Display the original array
System.out.println("Initial Array "+Arrays.toString(arr));
int first = arr[0]; //Initialize the first element of the array to a variable
int start = 0;
// swaping each element with the first element
for (int i = 1; i < arr.length; i++) {
arr[start++] = arr[i];
arr[i] = first;
}
//Display the updated array
System.out.println("Updated Array" +Arrays.toString(arr));
}
}
输入元素数量:
5
输入数组元素
1 4 3 6 8 2 6 7 9
初始数组[ 1 4 3 6 8 2 6 7 9 ]
更新数组[4 3 6 8 2 7 9 1]
Java 程序：将每个元素递增 1 并打印数组
在本教程中，我们将学习如何将数组的每个元素递增 1，然后打印递增后的数组。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入数组元素:34 52 67 87 98 12 79 54 89
产量: 35 53 68 88 99 13 80 55 90
程序 1:将数组中的每个元素递增 1，然后打印递增后的数组
在这种情况下，我们将看到如何将每个元素递增 1，然后在预定义值时打印更新的元素。预定义意味着值已经在程序中定义。
算法
- 开始
- 声明数组。
- 初始化数组。
- 声明一个存储数组大小的变量。
- 首先显示原始数组。
- 使用 for 循环遍历所有元素。
- 现在，将每个值递增 1，并将其存储在数组中。
- 同样，通过使用 for 循环显示更新后的数组的所有元素。
- 停下来。
下面是相同的代码。
下面的程序演示了如何将每个元素递增 1，然后在数组中预定义值时打印更新的元素。
/*Java program to increment the elements of an array by one and then print the updated array*/
import java.util.*;
public class Main
{
public static void main(String args[])
{
//Define the array and its elements
int arr[]={10 ,20, 30 ,50, 40 ,60, 70, 89,71};
//Define the length of the array
int n=arr.length;
//Display the original array
System.out.println("Initial Array is :");
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println("");
for(int i=0;i<n;i++)
{
arr[i]=arr[i]+1; //Increment the elements by one
}
//Display the updated array
System.out.println("Updated Array is ");
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println("");
}
}
初始数组为:
10 20 30 50 40 60 70 89 71
更新数组为
11 21 31 51 41 61 71 90 72
程序 2:将数组中的每个元素递增 1，然后打印递增后的数组
在这种情况下，我们将看到如何将每个元素递增 1，然后在值是用户定义的时候打印更新的元素，也就是说，我们将要求用户输入数组的元素。
算法
- 开始
- 声明一个存储数组大小的变量。
- 要求用户输入元素的总数。
- 声明数组。
- 要求用户输入数组的元素。
- 首先显示原始数组。
- 使用 for 循环遍历所有元素。
- 现在，将每个值递增 1，并将其存储在数组中。
- 同样，通过使用 for 循环显示更新后的数组的所有元素。
- 停下来。
下面的程序演示了如何将每个元素递增 1，然后在用户定义值时打印更新的元素。
/*Java program to increment the elements of an array by one and then print the updated array*/
import java.util.Arrays;
import java.util.Scanner;
import java.util.*;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
//Display the original array
System.out.println("Initial Array is :");
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println("");
for(int i=0;i<n;i++) //Traverse through the elements of the array
{
arr[i]=arr[i]+1; //Increment the elements by one
}
//Display the updated array
System.out.println("Updated Array is ");
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println("");
}
}
输入元素总数 10
输入数组的元素 2 3 4 1 5 6 11 9 87 6
初始数组为:
2 3 4 1 5 6 11 9 87 6
更新数组为
3 4 5 2 6 7 12 10 88 7
Java 程序：从指定位置拆分数组
原文：https://www.studytonight.com/java-programs/java-program-to-split-an-array-from-specified-position
在本教程中，我们将学习如何从指定位置拆分数组。这意味着现在数组将分成两个独立的数组。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:8 7 9 5 4 1 6 0 9 3 4
输出:位置= 5
数组 1: 8 7 9 5 4
数组 2: 3 1 6 0 9 8 3 4
程序 1:从指定位置拆分数组
在此方法中，我们将看到如何使用循环从指定位置拆分数组。
算法
- 开始
- 声明数组的大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组。
- 输入要拆分数组的位置。
- 声明另外两个数组来存储划分后的数组。
- 将指定位置的元素复制到一个数组中。
- 将下一半的元素复制到另一个数组中。
- 显示两个数组。
- 停下来。
下面的程序演示了如何使用循环从指定位置拆分数组。
/*Java program to split an array from a specified position*/
import java.util.*;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
System.out.println("Enter the position of the array : ");
int pos=sc.nextInt(); //Enter the position from where you want to split the array
int brr[]=new int[pos]; //Array to store the first half
int z=n-pos;
int crr[]=new int[z]; //Array to store the second half of the array
//Display the elements of the original array
System.out.println("Original Array Elements are ");
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+ " ");
}
System.out.println("");
//Copy the first half elements
for(int i=0;i<pos;i++)
{
brr[i]=arr[i];
}
//Print the first half elements
System.out.println("The first array elements are : ");
for(int i=0;i<pos;i++)
{
System.out.print(brr[i]+ " ");
}
System.out.println("");
//Copy the second half elements
int k=0;
for(int i=pos;i<n;i++)
{
crr[k]=arr[i];
k++;
}
//Print the second half elements
System.out.println("The second array elements are : ");
for(int t=0;t<z;t++)
{
System.out.print(crr[t]+ " ");
}
}
}
输入元素总数 10
输入数组的元素 2 3 4 1 5 6 7 2 8 9
输入数组的位置:4
原始数组元素为
2 3 4 1 5 6 7 2 8 9
第一个数组元素为:
2 3 4 1
第二个数组元素为:
5 6 7 2 8 9
程序 2:从指定位置拆分数组
在这个方法中，我们将看到如何使用Arrays.copyofRange()方法从指定位置拆分数组。
算法
- 开始
- 声明数组的大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组。
- 输入要拆分数组的位置。
- 声明另外两个数组来存储划分后的数组。
- 使用
Arrays.copyofRange()方法将指定位置的元素复制到一个数组中。 - 使用
Arrays.copyofRange()方法将下一半的元素复制到另一个数组中。 - 显示两个数组。
- 停下来。
下面的程序演示了如何使用Arrays.copyofRange()方法从指定位置拆分数组。
/*Java program to split an array from a specified position*/
import java.util.*;
import java.util.Arrays;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
System.out.println("Enter the position of the array : ");
int pos=sc.nextInt(); //Enter the position from where you want to split the array
int brr[]=new int[pos]; //Array to store the first half
int z=n-pos;
int crr[]=new int[z]; //Array to store the second half of the array
//Display the elements of the original array
System.out.println("Original Array Elements are ");
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+ " ");
}
System.out.println("");
//Copy the first half elements
brr=Arrays.copyOfRange(arr, 0, pos);
//Print the first half elements
System.out.println("The first array elements are : ");
for(int i=0;i<pos;i++)
{
System.out.print(brr[i]+ " ");
}
System.out.println("");
//Copy the second half elements
crr=Arrays.copyOfRange(arr, pos, n);
//Print the second half elements
System.out.println("The second array elements are : ");
for(int t=0;t<z;t++)
{
System.out.print(crr[t]+ " ");
}
}
}
输入元素总数 10
输入数组的元素 4 5 8 3 1 4 6 7 3 2
输入数组的位置:6
原始数组元素为
4 5 8 3 1 4 6 7 3 2
第一个数组元素为:
4 5 8 3 1 4
第二个数组元素为:
6 7 3 2
Java 程序：识别给定数组中缺失数字
在本教程中，我们将学习如何识别数组中缺失的元素。这意味着我们必须找到 n-1 个整数列表中缺少的一个元素，其中整数在 1 到 n 的范围内，并且列表中没有重复。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入: 1 2 4 5 6
输出:缺失元素为 3。
程序 1:使用总和技术查找缺失元素
在这个程序中，我们将看到如何使用总和技术来识别数组中缺失的元素。这种方法背后的逻辑是，首先我们通过使用公式 sum=(n+1)(n+2)/2 找到数组中所有元素的总和。这里，我们使用公式 sum=(n+1)(n+2)/2，而不是 sum=(n)*(n+1)/2，因为这里的元素总数是 n，但是由于缺少一个元素，所以总数加起来是 n+1。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 使用公式 sumtotal= n*(n+1)/2 计算前 n 个自然数的总和
- 声明一个变量和来存储数组元素的和。
- 使用 for 循环遍历数组的每个元素。
- 从计算的总和中扣除每个元素。
- 总和中剩余的元素将是缺少的元素。
- 打印总和。
- 停下来。
下面的程序演示了如何使用总和技术识别数组中缺少的元素。
/*Java Program to find the missing element*/
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
int sum=(n+1)*(n+2)/2; //Calculate the expected sum of all the elements from 1 to n
for(int i=0;i<n;i++)
{
sum=sum-arr[i]; //Subtract each element from the sum
}
System.out.println("Missing Element is "+sum); //Print the missing element
}
}
输入元素总数 4
输入数组的元素 1 2 4 5
缺少的元素是 3
程序 2:使用异或技术找到丢失的元素
在这个程序中，我们将看到如何使用异或技术识别数组中丢失的元素。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 声明两个变量。将第一个变量初始化为数组的第一个元素，将第二个变量初始化为 1。
- 使用 for 循环迭代所有元素。
- 求每个元素与第一个变量的异或。
- 使用另一个 for 循环遍历所有元素。
- 求每个元素与第二个变量的异或。
- 通过对上述结果变量进行异或运算，找到缺失的元素。
- 打印缺失的元素。
- 停下来。
下面的程序演示了如何使用异或技术识别数组中丢失的元素。
/*Java Program to find the missing element*/
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
int x1 = arr[0];
int x2 = 1;
/* For xor of all the elements in array */
for (int i = 1; i < n; i++)
x1 = x1 ^ arr[i];
/* For xor of all the elements from 1 to n+1 */
for (int i = 2; i <= n + 1; i++)
{
x2 = x2 ^ i;
}
int melement=x1 ^ x2;
System.out.println("Missing Element is "+melement); //Print the missing element
}
}
输入元素总数 7
输入数组的元素 1 2 3 4 5 7 8
缺少的元素是 6
Java 程序：找到两个差最大的元素
在本教程中，我们将学习如何在数组中找到 2 个元素，使它们之间的差异最大。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入: 7 8 5 4 3 2 1
输出:最大差值为 8-1 = 7
计划 1:找出最大的差异
在这个方法中，我们将看到如何通过比较和检查每对元素的差异来找到数组中的 2 个元素，以便它们之间的差异最大。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 对同一个循环使用两个。
- 使用第一个 for 循环来保存元素。
- 使用第二个 for 循环来计算拾取的元素与数组中所有其他元素之间的差异。
- 同时将差值与计算出的最大差值进行比较。
- 检查任意两个元素之间的所有可能差异。
- 打印差异最大的元素。
- 停下来。
下面的程序演示了如何找到数组中的 2 个元素，使它们之间的差异最大。
/*Java Program to find 2 Elements in the Array such that Difference Between them is Largest*/
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
int difference, largestDifference = arr[1] - arr[0];
int element1 = arr[1], element2 = arr[0]; // two elements ele1 and ele2 .
int res[] = new int[3]; // Array to store the difference
/* Check for all possible difference between any 2 elements in the array and finally select the elements whose difference is the largest */
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j < n; j++)
{
difference = Math.abs(arr[i] - arr[j]);
if (difference > largestDifference)
{
largestDifference = difference;
element1 = arr[i];
element2 = arr[j];
}
}
}
res[0] = largestDifference;
res[1] = element1;
res[2] = element2;
System.out.println( "Two elements with largest difference are "
+ res[1] + " and " + res[2]);
System.out.println("The Greatest Difference is "
+ res[0]);
}
}
输入元素总数 10
输入数组的元素 7 3 5 1 3 6 8 9 5 4
两个元素相差最大的是 1 和 9
相差最大的是 8
程序 2:找到最大的差异
在这个方法中，我们将看到如何通过比较和检查每对元素的差异来找到数组中的 2 个元素，以便它们之间的差异最大。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 使用 Array.sort()对数组进行排序。
- 第一个和最后一个元素将是数组中的最小和最大元素。
- 这两个元素之间的差异将给出最大的元素。
- 打印差异最大的元素。
- 停止
说明:下面的程序演示了如何找到数组中的 2 个元素，使它们之间的差异最大。
/*Java Program to find 2 Elements in the Array such that Difference Between them is Largest*/
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
Arrays.sort(arr); //Sort the array
System.out.println("Two elements with the largest difference are "+arr[n-1]+" and "+arr[0]);
int difference=arr[n-1]-arr[0];
System.out.println("The largest difference is "+difference);
}
}
输入元素总数 10
输入数组的元素 8 7 6 59 7 6 42 5 7 9
两个元素相差最大的是 59 和 5
相差最大的是 54
Java 程序：计算元素出现次数
在本教程中，我们将学习如何在数组中查找元素的出现。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入: 3 2 1 4 5 6 3 7
输出:
要搜索的元素:3
元素的出现:2
程序 1:查找数组中元素的出现
在这个方法中，我们将看到如何使用循环来查找数组中每个元素的出现。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 输入您想知道其频率的元素。
- 声明一个出现变量并将其初始化为 0。
- 使用 for 循环遍历数组的所有元素。
- 如果元素与数组元素匹配，则增加出现次数。
- 打印每个元素的出现。
- 停止
下面的程序演示了如何使用循环来查找数组中每个元素的出现。
/*Java Program to find the occurence of each element in an array*/
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
//Enter the element whose frequency you want to know
System.out.println("Enter the element whose frequency you want to know");
int ele=sc.nextInt();
int occ=0;
// Traverse through map and check frequencies
for(int i=0;i<n;i++)
{
if(ele==arr[i])
{
occ++; //Increment the occurrence once the element is found
}
}
//Print the element and its frequency
System.out.println(ele+" occurred "+occ+" times ");
}
}
输入元素总数 10
输入数组的元素 2 7 6 7 8 9 5 7 9
输入你想知道其频率的元素 7
7 出现 4 次
程序 2:查找数组中元素的出现
在这个方法中，我们将看到如何使用 hashmap 来查找数组中每个元素的出现。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 在 hashmap 中插入所有数组元素。
- 遍历数组元素，并使用 for 循环计算频率。
- 输入您想知道其频率的元素。
- 再次遍历映射并检查频率。
- 打印元素的频率。
- 停止
下面的程序演示了如何使用HashMap来查找数组中每个元素的出现。
/*Java Program to find the occurence of each element in an array*/
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
Map<Integer, Integer> mp = new HashMap<>();
// Traverse through array elements and count frequencies
for (int i = 0; i < n; i++)
{
if (mp.containsKey(arr[i]))
{
mp.put(arr[i], mp.get(arr[i]) + 1);
}
else
{
mp.put(arr[i], 1);
}
}
//Enter the element whose frequency you want to know
System.out.println(“Enter the element whose frequency you want to know”);
int ele=sc.nextInt();
int occ=0;
// Traverse through map and check frequencies
for (Map.Entry<Integer, Integer> entry : mp.entrySet())
{
if(ele==entry.getKey())
{
occ=entry.getValue();
}
}
//Print the element and its frequency
System.out.println(ele+" occurred "+occ+" times ");
}
}
输入元素总数 10
输入数组的元素 8 7 6 59 7 9 5 7 9
输入你想知道其频率的元素 9
9 出现 3 次
Java 程序：接受数组元素并计算总和
在本教程中，我们将学习如何接受数组元素并计算总和。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入: 91 72 63 54 91 21 43 45 64 40
输出:数组中所有元素之和为 584
程序 1:计算数组元素的总和
在这个方法中，我们将看到如何接受数组的元素，并使用 for-each 循环计算数组中所有元素的总和。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 声明一个变量和来存储数组中所有元素的和。
- 将变量初始化为 0。
- 使用 for-each 循环计算数组中所有元素的总和。
- 显示总和。
- 停下来。
下面的程序演示了如何接受数组的元素，并使用每个循环计算数组中所有元素的总和。
/*Java Program to find the sum of all the elements in the array using */
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare the array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize the array
{
arr[i]=sc.nextInt();
}
int sum = 0; //Variable to calculate the total sum
//Using For each loop
for( int num : arr)
{
sum = sum+num; //Increment the value of sum in each iteration
}
//Print the total sum
System.out.println("The sum of all the elements in the array is "+sum);
}
}
输入元素总数 10
输入数组的元素 98 71 62 55 34 21 90 73 21 32
数组中所有元素的总和为 557
程序 2:计算数组元素的和
在这个方法中，我们将看到如何接受数组的元素，并使用 while 循环计算数组中所有元素的总和。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 声明一个变量和来存储数组中所有元素的和。
- 将变量初始化为 0。
- 声明另一个变量来遍历数组的所有元素。
- 将其初始化为 0。
- 使用 while 循环计算数组中所有元素的总和。
- 在每次迭代中增加总和的值。
- 在每次迭代中增加另一个变量的值，遍历所有元素。
- 显示总和。
- 停下来。
下面的程序演示了如何接受数组的元素，并使用 while 循环计算数组中所有元素的总和。
/*Java Program to find the sum of all the elements in the array*/
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
int sum = 0; //Variable to store the sum
//Using while loop calculate the sum
int i=0; //Variable to iterate through all the elements
while(i!=n)
{
sum=sum+arr[i]; //Increment the value of sum in each iteration
I++; //Increment to iterate to the next element
}
//Print the sum
System.out.println("The sum of all the elements in the array is "+sum);
}
}
输入元素总数 10
输入数组的元素 9 7 6 5 91 21 43 45 64 40
数组中所有元素的总和为 331
Java 程序
Java 程序：for循环
原文：https://www.studytonight.com/java-programs/java-for-loop-programs
在本教程中，我们将学习如何在不同的场景中实现 for 循环。但是在继续之前，如果你不熟悉 for 循环的概念，那么一定要查看 Java 中 Loops 的文章。
程序 1: Java For 循环程序
在这个程序中，我们将看到如何在 java 中实现 for 循环程序。在这里，我们将考虑一个场景，我们将找到一个特定数字的乘法表。我们将为每个元素使用 for 循环，而不是为每个元素编写乘法表。我们将编写一次语句，并多次实现。
算法:
- 开始
- 创建 Scanner 类的实例。
- 宣布一个数字
- 要求用户初始化数字。
- 使用 for 循环打印该数字的乘法表。
- 显示结果。
- 停下来。
下面是 Java 中 for 循环的代码示例。
//Java Program to find the multiplication table of a given number
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter a number: ");
int n=sc.nextInt(); //Declare and initialize the number
System.out.println("The multiplication table of "+n+" is: ");
//Print the multiplication table
for(int i=1;i<=10;i++)
{
System.out.println(n+" * "+i+" = "+ (n*i));
}
}
}
输入一个数字:5
5 的乘法表为:
5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50
程序 2: Java For 循环程序
In this program, we will see how to implement a for each loop program in java.
算法
- 开始
- 创建扫描仪类的实例。
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明一个数组。
- 要求用户初始化数组。
- 使用 for 循环初始化数组。
- 每个循环使用一个来打印数组元素。
- 打印数组元素。
- 停止。
下面是 Java 中 for 循环的代码示例。
//Java Program to see the implementation of for and for-each loop
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the size of the array: ");
int n=sc.nextInt(); //Declare and initialize the number
int arr[]=new int[n]; //Declare an Array
System.out.println("Enter the array elements: ");
//Initialize the array
for(int i=0; i<n; i++)
{
arr[i]=sc.nextInt();
}
System.out.println("The array elements are: ");
//Print the number infinite times
for(int t:arr)
{
System.out.println(t);
}
}
}
输入数组大小:5
输入数组元素:1 2 3 4 5
数组元素为:
1
2
3
4
5
Java 程序：程序 3:实现循环
In this program, we will see how to implement an infinite for loop. A point to be noted here is that, in order to exit from an infinite loop, you need to press ctrl+c.
算法:
- 开始
- 创建扫描仪类的实例。
- 申报一个数字。
- 要求用户初始化数字。
- 使用 for 循环打印无限次。
- 在 for 循环中给出无限条件。
- 显示结果。
- 停止。
Below is the java code example for the for loop.
//Java Program to see the implementation of infinite for loop
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter a number: ");
int n=sc.nextInt(); //Declare and initialize the number
//Print the number infinite times
for(int i=1;i<=10;i--)
{
System.out.println(i + " The entered number is "+n);
}
}
输入数字:5
1 输入的数字是 5
0 输入的数字是 5
-1 输入的数字是 5
-2 输入的数字是 5
-3 输入的数字是 5
-4 输入的数字是 5
ctrl+c
Java 程序：程序 4:实现循环
In this program, we will see how to print a number infinite times using a for loop. A point to be noted here is that, in order to exit from an infinite loop, you need to press ctrl+c.
算法:
- 开始
- 创建扫描仪类的实例。
- 申报一个数字。
- 要求用户初始化数字。
- 使用 for 循环打印无限次。
- 在 for 循环中给出无限条件。
- 显示结果。
- 停止。
Below is the code for the same.
//Java Program to see the implementation of infinite for loop
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number: ");
int n=sc.nextInt(); //Declare and initialize the number
//Infinite Loop Example
for(; ;)
{
System.out.println("Number is "+n);
}
}
}
输入数字:3
数字是 3
数字是 3
数字是 3
数字是 3
数字是 3
数字是 3
数字是 3
数字是 3
数字是 3
ctrl+c
Java 程序：从链表末尾查找第n个节点
原文：https://www.studytonight.com/java-programs/java-program-to-find-nth-node-from-end-of-linked-list
在本教程中，我们将看到如何在 java 中从链表的末尾找到第 n 个节点。LinkedList 是一种线性数据结构，其中元素不存储在连续的位置，每个元素都是一个单独的对象，具有数据部分和地址部分。每个元素都被称为一个节点。由于插入和删除的动态性和容易性，它们比数组更受欢迎。但是在继续之前，如果你不熟悉 java 中链表的概念，那么一定要查看一下 Java 中链表上的文章。
输入:输入链表元素:6 7 8 4 5 1 3 2 5
输出:链表末尾的第 6 个节点是:4
这可以通过使用以下方法来实现:
方法 1:使用链表的长度。
方法 2:使用两点概念。
让我们看看这些方法中的每一种，以便更好地理解。
Java 程序：程序 1:从链表末尾找到第 n 个节点
在这个程序中，我们将看到如何使用链表的长度在 java 中从链表的末尾找到第 n 个节点。
算法:
- 开始
- 使用链表数据结构创建
String类型的链表。 - 现在向链表添加节点。
- 调用用户定义的函数，从链表的末尾开始计算第 n 个节点。
- 首先，计算链表的长度。
- 现在，打印链表开头的第(length–n+1)个节点。
- 停止
让我们看看下面的例子，以更好地理解上述算法。
//Java program to find nth node from end of linked list
public class LinkedList
{
Node head;
class Node
{
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
void printNthFromEnd(int n)
{
int len = 0;
Node temp = head;
while (temp != null)
{
temp = temp.next;
len++;
}
if (len < n)
return;
temp = head;
for (int i = 1; i < len - n + 1; i++)
temp = temp.next;
System.out.println(n+"th node from the end is "+temp.data);
}
public void add(int newData)
{
Node newNode = new Node(newData);
newNode.next = head;
head = newNode;
}
public static void main(String[] args)
{
LinkedList ll = new LinkedList();
ll.add(12);
ll.add(8);
ll.add(21);
ll.add(96);
ll.add(52);
ll.add(27);
ll.add(14);
ll.printNthFromEnd(6);
}
}
距终点第 6 个节点是 27
Java 程序：程序 2:从链表末尾找到第 n 个节点
在这个程序中，我们将看到如何使用两个指针在 java 中从链表的末尾找到第 n 个节点。
算法:
- 开始
- 使用链表数据结构创建
String类型的链表。 - 现在向链表添加节点。
- 调用用户定义的函数，从链表的末尾开始计算第 n 个节点。
- 声明两个指针:指针 1 和指针 2。
- 初始化指向 head 的两个指针。
- 首先，将第一个指针从头部移动到 n 个节点。
- 现在逐个移动两个指针，直到引用指针到达末尾。
- 现在第二个指针将从末尾指向第 n 个节点。
- 返回第二个指针。
- 显示结果。
- 停止
让我们看看下面的例子，以更好地理解上述算法。
//Java program to find nth node from end of linked list
public class LinkedList
{
Node head;
class Node
{
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
void printNthFromEnd(int n)
{
Node ptr1 = head;
Node ptr2 = head;
int count = 0;
if (head != null)
{
while (count < n)
{
if (ptr2 == null)
{
System.out.println(n+ " is greater than the number of nodes in the list");
return;
}
ptr2 = ptr2.next;
count++;
}
if(ptr2 == null)
{
head = head.next;
if(head != null)
System.out.println(n +"th node from the last is "+head.data);
}
else
{
while (ptr2 != null)
{
ptr1 = ptr1.next;
ptr2 = ptr2.next;
}
System.out.println(n +"th node from the last is "+ptr1.data);
}
}
}
public void add(int newData)
{
Node newNode = new Node(newData);
newNode.next = head;
head = newNode;
}
public static void main(String[] args)
{
LinkedList ll = new LinkedList();
ll.add(12);
ll.add(8);
ll.add(42);
ll.add(29);
ll.add(32);
ll.add(87);
ll.add(53);
ll.printNthFromEnd(4);
}
}
倒数第 4 个节点是 29
Java 程序：计算数的幂
原文：https://www.studytonight.com/java-programs/java-program-to-calculate-the-power-of-a-number
在本教程中，我们将学习如何在 java 中找到一个数的幂。一个数的幂被定义为通过将基值乘以 n 次而得到的值，其中 n 是指数值。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入基值:2
输入指数值:4
输出: 2 升至 4 次方为 16.0
上述问题可以通过以下方式解决:
方法 1:使用 While 循环
方法 2:使用 For 循环
方法 3:使用电源()
让我们分别看看这些方法
Java 程序：程序 1:计算一个数的幂
在这个程序中，我们将看到如何使用 while 循环计算一个数的幂。
算法:
- 开始
- 创建 Scanner 类的实例。
- 为基数和指数声明两个变量。
- 要求用户初始化这两个变量。
- 使用 while 循环计算一个数的幂。
- 打印计算值。
- 停止
下面是相同的代码。
//Java Program to Calculate the Power of a number
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter the base value: ");
int base = sc.nextInt();
System.out.println("Enter the exponent value: ");
int exp = sc.nextInt();
long result = 1;
System.out.print(base+ " raised to the power "+ exp+" is: ");
while (exp != 0)
{
result *= base;
--exp;
}
System.out.println(result);
}
}
输入基值:2
输入指数值:3
2 的 3 次方是:8
Java 程序：程序 2:计算一个数的幂
在这个程序中，我们将看到如何使用 for 循环计算一个数的幂。
算法:
- 开始
- 创建 Scanner 类的实例。
- 为基数和指数声明两个变量。
- 要求用户初始化这两个变量。
- 使用 for 循环计算一个数的幂。
- 打印计算值。
- 停止
下面是相同的代码。
//Java Program to Calculate the Power of a number
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter the base value: ");
int base = sc.nextInt();
System.out.println("Enter the exponent value: ");
int exp = sc.nextInt();
long result = 1;
System.out.print(base+ " raised to the power "+ exp+" is: ");
for (;exp != 0; --exp)
{
result *= base;
}
System.out.println(result);
}
}
输入基值:3
输入指数值:3
3 的 3 次方是:27
Java 程序：程序 3:计算一个数的幂
在这个程序中，我们将看到如何使用幂()计算一个数的幂。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明两个变量。
- 要求用户初始化变量。
- 使用 Math.pow()计算数字的幂。
- 打印数字的幂的值。
- 停止
下面是相同的代码。
//Java Program to Calculate the Power of a number
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter the base value: ");
int base = sc.nextInt();
System.out.println("Enter the exponent value: ");
int exp = sc.nextInt();
System.out.print(base+ " raised to the power "+ exp+" is: ");
double result = Math.pow(base, exp);
System.out.println(result);
}
}
输入基值:8
输入指数值:2
8 的 2 次方是:64.0
Java 程序：计算数字平方根
原文：https://www.studytonight.com/java-programs/java-program-to-find-square-root-of-a-number
在本教程中，我们将学习如何在 java 中找到一个数的平方根。一个数的平方根被定义为在乘法时给出原始数的值。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入数字:49
输出:数字的平方根是 7.0
上述问题可以通过以下方式解决:
方法 1:使用用户定义的方法
方法 2:使用预定义的方法
让我们分别看看这些方法。
Java 程序：程序 1:寻找一个数的平方根
在这个程序中，我们将学习如何在 java 中找到一个数字的平方根，而不使用预定义的方法。在这里，我们将使用下面的逻辑来寻找一个数的平方根。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量。
- 要求用户初始化变量。
- 调用用户定义的方法来查找数字的平方根。
- 声明一个临时变量。
- 声明另一个变量来存储数字/2 值。
- 使用边做边循环计算平方根。
- 计算数字的平方根并返回值。
- 现在，打印数字的平方根。
- 停止
下面是相同的代码。
//Java Program to Calculate the square root of a number
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter a number: ");
int n = sc.nextInt();
System.out.println("The square root of "+ n+ " is: "+squareRoot(n));
}
//user-defined method to find the square root
public static double squareRoot(int num)
{
//temporary variable
double temp;
double sqrtroot=num/2;
do
{
temp=sqrtroot;
sqrtroot=(temp+(num/temp))/2;
}
while((temp-sqrtroot)!= 0);
return sqrtroot;
}
}
Ca
输入一个数字:45
45 的平方根是:6.73939939999
Java 程序：程序 2:寻找一个数的平方根
在这个程序中，我们将学习如何使用一个预定义的方法在 java 中找到一个数的平方根。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量。
- 要求用户初始化变量。
- 使用预定义的方法来寻找数字的平方根。
- 使用 Math.pow()计算数字的平方根。
- 打印数字的平方根值。
- 停止
下面是相同的代码。
//Java Program to Calculate the square root of a number
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter a number: ");
int num = sc.nextInt();
Double squareroot = Math.pow(num, 0.5);
System.out.println("The Square Root of the Given Number " + num + " = " + squareroot);
}
}
输入一个数字:36
给定数字 36 的平方根= 6.0
Java 程序：计算一个数的阶乘
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-factorial-of-a-number
在本教程中，我们将学习如何在 java 中找到一个数的阶乘。一个数的阶乘是从 1 到该数的所有整数的乘积。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入数字:5
输出:输入数字的阶乘为:120
程序 1:求一个数的阶乘
在这个程序中，我们将学习如何使用 while 循环找到一个数的阶乘。
算法
-
开始
-
创建扫描仪类的实例。
-
声明一个变量。
-
要求用户初始化变量。
-
声明一个循环变量和另一个变量来存储数字的阶乘。
-
将两个变量都初始化为 1。
-
使用 while 循环计算阶乘。
-
运行循环，直到循环变量小于或等于该数字。
-
在每次迭代中更新阶乘。
-
在每次迭代中增加循环变量。
-
打印数字的阶乘。
-
停下来。
下面是用 Java 打印一个数字的阶乘的代码示例。
//Java Program to find the Factorial of a Number
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
//Declare and Initialize the variable
System.out.println("Enter the number: ");
int num=sc.nextInt();
int i=1,fact=1;
while(i<=num)
{
fact=fact*i;
i++;
}
System.out.println("Factorial of the number: "+fact);
}
}
输入数字:5
数字的阶乘:120
Java 程序：程序 2:寻找一个数的阶乘
在这个程序中，我们将学习如何使用 for 循环来求一个数的阶乘。
算法
-
开始
-
创建扫描仪类的实例。
-
声明一个变量。
-
要求用户初始化变量。
-
声明一个变量来存储数字的阶乘。
-
将变量初始化为 1。
-
使用 for 循环计算阶乘。
-
通过在每次迭代中将其与循环变量相乘来更新阶乘变量。
-
打印数字的阶乘。
-
停下来。
下面是用 Java 打印一个数字的阶乘的代码示例。
//Java Program to find the Factorial of a Number
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
//Declare and Initialize the variable
System.out.println("Enter the number: ");
int num=sc.nextInt();
int fact=1;
for(int i=1;i<=num;i++)
{
fact=fact*i;
}
System.out.println("Factorial of the number: "+fact);
}
}
输入数字:4
数字的阶乘:24
Java 程序：程序 3:寻找一个数的阶乘
在这个程序中，我们将使用带有用户定义值的递归找到一个数的阶乘。这里，我们将要求用户输入一个值，然后通过递归调用函数来计算阶乘。
算法
-
开始
-
声明一个变量来存储一个数字。
-
要求用户初始化数字。
-
检查是否可以计算阶乘。
-
如果数字大于等于 0，则调用递归函数来计算输入数字的阶乘。
-
如果数字小于 0，则打印无法计算阶乘的消息。
-
如果输入的数字是 0 或 1，则返回 1。
-
如果输入的数字不是 0 或 1，则通过递归调用相同的方法计算阶乘。
-
返回结果。
-
打印输入数字的阶乘。
-
停止
下面是用 Java 打印一个数字的阶乘的代码示例。
/*Java Program to find factorial of a number using Recursive Function*/
import java.util.Scanner;
public class Main
{
//Driver Code
public static void main(String[] args)
{
//Take input from the user
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number :");
int num = sc.nextInt(); //Input the number
if(num>=0)
{
//Call a recursive function to find the factorial
int factorial=findFactorial(num);
System.out.println("The factorial of the entered number is :"+factorial);
}
else
{
System.out.println("Factorial not possible.");
System.out.println("Please enter valid input.");
}
}
//Recursive Function to Find the Factorial of a Number
public static int findFactorial(int num)
{
if(num==0)
return 1;
else if(num==1)
return 1;
else
return num*findFactorial(num-1);
}
}
输入数字:8
输入数字的阶乘为:40320
Java 程序：交换两个数字
原文：https://www.studytonight.com/java-programs/java-program-to-swap-two-numbers
在本教程中，我们将学习如何在 java 中交换两个变量。交换两个变量意味着交换两个变量的值。例如，如果变量 A 包含 X 值，变量 B 包含一个值，那么交换后 A 包含 Y 值，B 包含 X 值。但是在继续之前，如果你不熟悉 Java 中变量的概念，那么一定要查看关于 Java 中变量的文章。
输入:第一个变量:3
第二个变量:6
输出:第一变量:6
第二个变量:3
程序 1:用 Java 交换两个数字
在这个程序中，我们将看到如何通过使用第三个变量来交换两个数字。
算法
-
开始
-
创建 Scanner 类的实例。
-
声明两个变量。
-
要求用户初始化变量。
-
交换前打印两个变量的值。
-
声明一个临时变量。
-
将第一个变量的值赋给临时变量。
-
现在，将第二个变量的值赋给第一个变量。
-
将包含第一个变量值的临时变量的值赋给第二个变量。
-
打印两个变量的值。
-
停下来。
下面是在 Java 中交换两个值的代码示例。
//Java Program to Swap two numbers using a temporary variable
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the first number");
int num1=sc.nextInt();
System.out.println("Enter the second number");
int num2=sc.nextInt();
System.out.println("Before Swapping numbers are: ");
System.out.println("The first Number is "+num1);
System.out.println("The second Number is "+num2);
//Use a temporary variable to swap the numbers
int temp=num1;
num1=num2;
num2=temp;
System.out.println("After Swapping numbers are: ");
System.out.println("The first Number is "+num1);
System.out.println("The second Number is "+num2);
}
}
输入第一个数字 3
输入第二个数字 5
换号前是:
第一个数字是 3
第二个数字是 5
换号后是:
第一个数字是 5
第二个数字是 3
程序 2:用 Java 交换两个数字
在这个程序中，我们将看到如何在不使用第三个变量的情况下交换两个数字。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明两个变量。
-
要求用户初始化变量。
-
交换前打印两个变量的值。
-
从第一个变量中减去第二个变量，并将该值赋给第一个变量。
-
将两个变量的值相加，并将其赋给第二个变量。
-
从第二个变量中减去第一个变量的值，并将该值赋给第一个变量。
-
打印两个变量的值。
-
停止
下面是在 Java 中交换两个值的代码示例。
//Java Program to Swap two numbers without using a temporary variable
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the first number");
int num1=sc.nextInt();
System.out.println("Enter the second number");
int num2=sc.nextInt();
System.out.println("Before Swapping numbers are: ");
System.out.println("First Number is "+num1);
System.out.println("Second Number is "+num2);
num1=num1-num2;
num2=num1+num2;
num1=num2-num1;
System.out.println("After Swapping numbers are: ");
System.out.println("First Number is "+num1);
System.out.println("Second Number is "+num2);
}
}
输入第一个数字 8
输入第二个数字 9
换号前是:
第一个数字是 8
第二个数字是 9
换号后是:
第一个数字是 9
第二个数字是 8
Java 程序：打印 ASCII 值
原文：https://www.studytonight.com/java-programs/java-program-to-print-the-ascii-values
在本教程中，我们将学习如何在 Java 中打印字符的 ASCII 值。ASCII 是用于在电子设备上表示字符的标准。它是一个 7 位代码，由 33 个不可打印字符和 95 个可打印字符组成，包括字母、数字、标点符号和控制字符。
但是在继续之前，如果你不熟悉 java 中的类型转换的概念，那么一定要查看关于 Java 中类型转换的文章。
输入:输入字符:Z
输出:Z 的 ASCII 值为 90
程序 1:用 Java 打印 ASCII 值
在本程序中，我们将学习如何通过将字符分配给整数数据类型来打印字符的 ASCII 值。
算法
-
开始
-
创建 Scanner 类的实例。
-
声明一个
Character类型变量。 -
要求用户初始化变量。
-
声明一个
Integer类型变量。 -
将字符变量赋给整数变量。
-
打印两个变量的值。
-
停止
下面是打印 ASCII 值的 Java 代码。
//Java Program to print the ASCII values
import java.util.*;
public class Main
{
//Driver code
public static void main(String []args)
{
//Take input from the user
//Create instance of the Scanner class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the character whose ASCII value you want to know ");
char ch=sc.next().charAt(0);
int value=ch;
System.out.println("Character is "+ch+" and ASCII value is "+value);
}
}
输入想要知道 r 的 ASCII 值的字符
字符为 r，ASCII 值为 114
程序 2:用 Java 打印 ASCII 值
在这个程序中，我们将学习如何通过类型转换打印字符的 ASCII 值。
算法
-
开始
-
创建 Scanner 类的实例。
-
声明一个
Character类型变量。 -
要求用户初始化变量。
-
声明一个
Integer类型变量。 -
使用(int)将
Character类型转换为Integer类型 -
将此赋值给字符变量。
-
打印两个变量的值。
-
停止
下面是打印 ASCII 值的 Java 代码。
//Java Program to print the ASCII values
import java.util.*;
public class Main
{
//Driver code
public static void main(String []args)
{
//Take input from the user
//Create instance of the Scanner class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the character whose ASCII value you want to know ");
char ch=sc.next().charAt(0);
int value=(int)ch;
System.out.println("Character is "+ch+" and ASCII value is "+value);
}
}
输入想要知道其 ASCII 值的字符
字符为 B，ASCII 值为 66
程序 3:用 Java 打印 ASCII 值
在这个程序中，我们将学习如何打印英文字母的所有 ASCII 值。
算法:
- 开始
- 使用 for 循环遍历所有英文字母。
- 通过使用(int)将
Character类型转换为Integer类型来打印字符及其 ASCII 值。 - 停止
下面是打印 ASCII 值的 Java 代码。
//Java Program to print the ASCII values
public class Main
{
//Driver code
public static void main(String []args)
{
for(char ch='A';ch<='Z';ch++)
{
System.out.println("The ASCII value of "+ch+" is "+(int)ch);
}
}
}
A 的 ASCII 值为 65
B 的 ASCII 值为 66
C 的 ASCII 值为 67
D 的 ASCII 值为 68
E 的 ASCII 值为 69
F 的 ASCII 值为 70
G 的 ASCII 值为 71
H 的 ASCII 值为 72
I 的 ASCII 值为 73
J 的 ASCII 值为 74
K 的 ASCII 值为 75
L 的 ASCII 值为 76
M 的 ASCII 值为 77
N 的 ASCII 值为 78
O 的 ASCII 值为 79
P 的 ASCII 值为 80
Q 的 ASCII 值为 81
R 的 ASCII 值为 82
S 的 ASCII 值为 83
T 的 ASCII 值为 84 U 的 ASCII 值为 85
V 的 ASCII 值为 86
W 的 ASCII 值为 87
X 的 ASCII 值为 88
Y 的 ASCII 值为 89
Z 的 ASCII 值为 90
Java 程序：检查阿姆斯特朗数字
原文：https://www.studytonight.com/java-programs/java-program-to-check-armstrong-number
在本教程中，我们将学习如何检查数字是否是阿姆斯特朗。
如果每一个数字的 n 次方的和等于数字本身，那么 n 位数就被称为阿姆斯特朗数。例如，如果一个 3 位数的立方之和等于该数本身，则称该数为阿姆斯特朗数。
但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章
输入:输入数字:153
输出:是的，输入的数字 153 是阿姆斯特朗数字。
Java 程序：检查阿姆斯特朗数字
在这个节目中，我们将看到如何找到一个数字是否是阿姆斯特朗。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量。
-
要求用户初始化数字。
-
定义 3 种方法，一种是检查阿姆斯特朗，另一种是计算顺序，还有一种是计算升至幂的值。
-
使用 while 循环计算 order 函数中的总位数。
-
计算升至幂阶值的位数。
-
在 isArmstrong 方法中，检查输入的数字是否是阿姆斯特朗。
-
如果找到了阿姆斯特朗，那就还真否则就还假。
-
如果为真，则打印一条消息，说明输入的数字是阿姆斯特朗。
-
如果为假，则打印一条消息，说明输入的数字不是阿姆斯特朗数字。
-
显示消息。
-
停下来。
下面是检查阿姆斯特朗号的 Java 代码。
//Java Program to check Armstrong Number
import java.util.*;
public class checkArmstrong
{
int pow(int x, long y)
{
if( y == 0)
return 1;
if (y%2 == 0)
return pow(x, y/2)*pow(x, y/2);
return x*pow(x, y/2)*pow(x, y/2);
}
int order(int num)
{
int n = 0;
while (num != 0)
{
n++;
num = num/10;
}
return n;
}
boolean isArmstrong (int num)
{
// Calling order function
int n = order(num);
int temp=num, sum=0;
while (temp!=0)
{
int r = temp%10;
sum = sum + pow(r,n);
temp = temp/10;
}
// If satisfies Armstrong condition
return (sum == num);
}
// Driver Program
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number ");
int num = sc.nextInt();
checkArmstrong obj = new checkArmstrong();
if(obj.isArmstrong(num))
{
System.out.println("Yes "+num+" is an Armstrong number");
}
else
{
System.out.println(num+" is not an Armstrong number");
}
}
}
输入数字 1634
是的，1634 是阿姆斯特朗数字
程序 2:用 Java 检查阿姆斯特朗号
在这个程序中，我们将看到如何找到 0 到 1000 之间的阿姆斯特朗数。
算法:
-
开始
-
创建 Scanner 类的实例。
-
为该范围声明两个变量。
-
要求用户初始化范围。
-
声明另外三个变量来存储原始数字、总和和数字。
-
使用 for 循环迭代该范围内的所有元素。
-
将 temp 变量初始化为循环变量。
-
将总和初始化为 0。
-
求每个数字的立方之和。
-
检查总和是否等于原始数字。
-
如果相等，那么这个数字就是阿姆斯特朗。
-
如果不相等，那么这个数字就不是阿姆斯特朗。
-
显示所有阿姆斯特朗的数字。
-
停止
下面是检查阿姆斯特朗号的 Java 代码。
//Java Program to print all the Armstrong Number from 0 to 1000
import java.util.*;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the starting range: ");
int num1=sc.nextInt();
System.out.println("Enter the ending range: ");
int num2=sc.nextInt();
int temp, digit, sum;
for (int i = num1; i < num2; i++) {
temp = i;
sum = 0;
while (temp != 0)
{
digit = temp % 10;
sum = sum + digit * digit * digit;
temp /= 10;
}
if (sum == i)
System.out.println(i + " is an Armstrong Number");
}
}
}
输入起始范围:0
输入结束范围:1000
0 是阿姆斯特朗号
1 是阿姆斯特朗号
153 是阿姆斯特朗号
370 是阿姆斯特朗号
371 是阿姆斯特朗号
407 是阿姆斯特朗号
Java 程序：寻找完美数
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-perfect-number
如果一个数的所有因子之和(不包括数本身)等于该数，则称该数为完全数。例如，考虑数字 6。6 的因子是 1，2，3 和 6。现在，除了数本身，它的所有因子之和是 1+2+3=6。
这里，由于原始数等于除了数本身以外的所有因素的总和，因此它是一个完全数。
在本教程中，我们将学习如何在 java 中找到完美数。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章
输入:输入数字:34
输出: 34 不是一个完全数
Java 程序：寻找完全数
在这个程序中，我们将使用 for 循环检查数字是否完美。
算法
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量。
-
要求用户初始化变量。
-
调用一个方法检查数字是否完美。
-
声明一个变量来存储除数之和。
-
将总和初始化为 1。
-
使用 for 循环查找输入数字的除数。
-
每次输入数字的除数遇到时更新总和。
-
如果输入数字的所有除数之和等于输入的数字，则将其打印为一个完全数。
-
如果输入数字的所有除数之和不等于输入的数字，则将其打印为非完全数。
-
显示结果。
-
停止
下面是寻找完美数的 Java 代码。
// Program to find the perfect number in Java
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create instance of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number: ");
int num = sc.nextInt();
if (checkPerfect(num))
{
System.out.print(num+" is a perfect number ");
}
else
{
System.out.println(num+" is not a perfect number ");
}
}
static boolean checkPerfect(int num)
{
// To store sum of divisors
int sum = 1;
// Find all divisors and add them
for (int i = 2; i * i <= num; i++)
{
if (num % i==0)
{
if(i * i != num)
sum = sum + i + num / i;
else
sum = sum + i;
}
}
// If sum of divisors is equal to number
// Then number is a perfect number
if (sum == num && num != 1)
return true;
return false;
}
}
输入数字:28
28 是一个完全数
Java 程序：程序 2:寻找完全数
在这个程序中，我们将使用 while 循环检查数字是否完美。
算法
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量。
-
要求用户初始化变量。
-
调用一个方法检查数字是否完美。
-
声明一个变量来存储除数和另一个循环变量。
-
将总和初始化为 0，并将循环变量初始化为 1。
-
使用 while 循环查找输入数字的除数。
-
每次输入数字的除数遇到时更新总和。
-
每次迭代后递增循环变量。
-
如果输入数字的所有除数之和等于输入的数字，则将其打印为一个完全数。
-
如果输入数字的所有除数之和不等于输入的数字，则将其打印为非完全数。
-
显示结果。
-
停止
下面是寻找完美数的 Java 代码。
// Program to find the perfect number in Java
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create instance of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number: ");
int num = sc.nextInt();
checkPerfect(num); //Call a method to check perfect
}
//Checks and Prints whether perfect or not
static void checkPerfect(int num)
{
// To store sum of divisors
int sum = 0,i=1;
while(i<num)
{
if(num % i == 0)
{
sum = sum + i;
}
i++;
}
if(sum == num)
{
System.out.println("The entered number "+num+" is a Perfect number");
}
else
{
System.out.println("The entered number "+num+" is not a Perfect number");
}
}
}
输入数字:35
输入的数字 35 不是完全数
Java 程序：程序 3:寻找完全数
在这个程序中，我们将找到一个范围内的完全数。
算法
-
开始
-
创建 Scanner 类的实例。
-
声明范围。
-
要求用户初始化范围。
-
使用 for 循环迭代该范围内的元素。
-
调用一个方法检查数字是否完美。
-
声明一个变量来存储除数和另一个循环变量。
-
将总和初始化为 0，并将循环变量初始化为 1。
-
使用 while 循环查找输入数字的除数。
-
每次输入数字的除数遇到时更新总和。
-
每次迭代后递增循环变量。
-
如果输入的所有数的除数之和等于输入的数，则返回 true。
-
如果输入的所有数的除数之和不等于输入的数，则返回 false。
-
展示完美的元素。
-
停止
下面是寻找完美数的 Java 代码。
// Program to find the perfect number in Java
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create instance of the Scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter the first number: ");
int num1 = sc.nextInt();
System.out.println("Enter the second number: ");
int num2 = sc.nextInt();
System.out.println("Perfect numbers within the given range are: ");
for(int i=num1;i<=num2;i++)
{
if(checkPerfect(i))
System.out.print(i+" ");
}
}
//Checks and Prints whether perfect or not
static boolean checkPerfect(int num)
{
// To store sum of divisors
int sum = 0,i=1;
while(i<num)
{
if(num % i == 0)
{
sum = sum + i;
}
i++;
}
if(sum == num)
return true;
return false;
}
}
输入第一个数字:2
输入第二个数字:50
给定范围内的完全数为:
6 28
Java 程序：使用条件运算符
原文：https://www.studytonight.com/java-programs/java-program-to-use-conditional-operator
在本教程中，我们将学习如何执行条件运算。条件运算符由三个操作数组成，用于计算布尔表达式。这个操作符的目标是决定；应该将哪个值赋给变量。它也被称为三元运算符。但是在继续之前，如果你不熟悉 java 中条件运算符的概念，那么一定要查看关于 Java 中运算符的文章。
输入:
输入第一个数字:4
输入第二个数字:4
字符串输出= (4==4)？“平等”:“不平等”
输出:相等
上述问题出现了两种情况:
情况 1:当值由用户定义时
情况 2:当值被预定义时
让我们分别看看这些案例。
程序 1:执行条件运算
在这个程序中，我们将看到当值是用户定义的时，如何执行条件“与”和条件“或”运算。这里，我们将首先要求用户输入值，然后执行条件“与”和条件“或”操作。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明三个变量。
- 要求用户初始化变量。
- 执行条件与运算和条件或运算。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to perform Conditional AND and OR operations
import java.util.*;
public class Main
{
public static void main(String args[])
{
//Take input from the user
//Create instance of the Scanner class
Scanner sc=new Scanner(System.in);
System.out.print("Enter the first number: ");
int x=sc.nextInt(); //Declare and Initialize the number
System.out.print("Enter the second number: ");
int y=sc.nextInt(); //Declare and Initialize the number
System.out.print("Enter the third number: ");
int z=sc.nextInt(); //Declare and Initialize the number
//Conditional AND Operator
//Conditional OR Operator
System.out.println("Result of : "+x+">"+y+" && "+x+">"+z+" || "+y+"<"+z);
System.out.println(x>y && x>z || y<z);
System.out.println("Result of ("+x+"<"+z+" || "+y+">"+z+") && "+x+"<"+y);
System.out.println((x<z || y>z) && x<y);
}
}
输入第一个数字:12
输入第二个数字:11
输入第三个数字:10
结果为:12>11&T9】12>10 | | 11<10
真
结果为(12<10 | | 11>10)&T15】12<11
假
程序 2:执行条件运算
在这个程序中，我们将看到当值在程序中预先定义时，如何执行条件“与”和条件“或”运算。
算法:
- 开始
- 声明三个变量。
- 初始化这些变量。
- 执行条件与运算和条件或运算。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to perform Conditional AND and OR operations
import java.util.*;
public class Main
{
public static void main(String args[])
{
int x= 9,y=8,z=6;
//Conditional AND Operator
//Conditional OR Operator
System.out.println("Result of : "+x+">"+y+" && "+x+">"+z+" || "+y+"<"+z);
System.out.println(x>y && x>z || y<z);
System.out.println("Result of ("+x+"<"+z+" || "+y+">"+z+") && "+x+"<"+y);
System.out.println((x<z || y>z) && x<y);
}
}
结果为:9>8&T6】9>6 | | 8<6
真
结果为(9<6 | | 8>6)&T12】9<8
假
程序 3:执行条件运算
在这个程序中，我们将看到当值是用户定义的时，如何执行三元运算。这里，我们将首先要求用户输入值，然后我们将使用三元运算符检查指定的条件，如果条件为真，将显示第一个表达式，如果条件为假，将显示第二个表达式。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明两个变量。
- 要求用户初始化变量。
- 使用三元运算符检查条件。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to perform ternary operation
import java.util.*;
public class Main
{
public static void main(String args[])
{
//Take input from the user
//Create instance of the Scanner class
Scanner sc=new Scanner(System.in);
System.out.print("Enter the first number: ");
int a=sc.nextInt(); //Declare and Initialize the number
System.out.print("Enter the second number: ");
int b=sc.nextInt(); //Declare and Initialize the number
String out = a==b ? "Yes":"No";
System.out.println("Is "+a+" == "+b+ "?");
System.out.println(out);
}
}
输入第一个数字:12
输入第二个数字:11
是 12 == 11？
否
程序 4:执行条件运算
在这个程序中，我们将看到当值在程序中被预定义时，如何执行三元运算。
算法:
- 开始
- 声明两个变量。
- 初始化变量。
- 使用三元运算符检查条件。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to perform ternary operator
public class Main
{
public static void main(String args[])
{
int a=9,b=8;
System.out.print("The entered number is: "+a);
System.out.print("The entered number is: "+b);
String out = a>=b ? "Yes both the numbers are the same":"No both the numbers are not the same";
System.out.println("Is "+a+" >= "+b+ "?");
System.out.println(out);
}
}
输入的数字是:9
输入的数字是:8
是 9 > = 8？
是的，两个数字相同
Java 程序：执行赋值操作
原文：https://www.studytonight.com/java-programs/java-program-to-perform-assignment-operations
在本教程中，我们将学习如何通过接受用户的输入来执行分配操作。但是在继续之前，如果你不熟悉 java 中赋值运算符的概念，那么一定要查看关于 Java 中运算符的文章。
输入: num1=10
num2=20
输出:
num1+=num2
num1 的值=30
num -=num2
num1 的值=10
上述问题出现了两种情况:
情况 1:当值被预定义时
情况 2:当值由用户定义时
让我们分别看看这些案例。
程序 1:执行分配操作
在本程序中，我们将在程序中预定义值时执行赋值操作。
算法:
- 开始
- 这里，我们将使用一个 switch case 从不同的赋值运算符中进行选择，如+=，-=，*=，/=，和%=。
- 声明两个变量。
- 初始化它。
- 执行所有赋值运算符，如+=、-=、*=、/=、和%=。
- 显示每个赋值操作的结果。
- 停下来。
下面是相同的代码。
//Java Program to perform Assignment Operator
import java.io.*;
public class Main
{
public static void main(String[] args)
{
// Declaring variables
int num1 = 10, num2 = 20;
int res;
System.out.println("Initial value of num1 = " + num1);
System.out.println("Initial value of num2 = " + num2);
// Adding & Assigning values
num1 += num2;
// Displaying the assigned values
System.out.println("Value of num1 after += is " + num1);
// Subtracting & Assigning values
num1 -= num2;
// Displaying the assigned values
System.out.println("Value of num1 after -= is " + num1);
// Multiplying & Assigning values
num1 *= num2;
// Displaying the assigned values
System.out.println("Value of num1 after *= is " + num1);
// Dividing & Assigning values
num1 /= num2;
// Displaying the assigned values
System.out.println("Value of num1 after /= is " + num1);
// Moduling & Assigning values
num1 %= num2;
// Displaying the assigned values
System.out.println("Value of num1 after %= is " + num1);
}
}
num 1 初始值= 10
num 2 初始值= 20
num 1+后的值为 30
num 1-后的值为 10
num 1 * =后的值为 200
num 1/=后的值为 10
num 1% =后的值为 0
程序 2:执行分配操作
在这个程序中，我们将看到当值是用户定义的时，如何在 java 中执行赋值操作。这里，首先我们将要求用户输入值，然后我们将执行赋值操作
算法:
- 开始
- 这里，我们将使用一个 switch case 从不同的赋值运算符中进行选择，如+=，-=，*=，/=，和%=。
- 为相同的声明一个变量。
- 请用户初始化它。
- 根据选择的操作，声明两个变量。
- 要求用户初始化变量。
- 执行赋值操作后显示结果。
- 停下来。
下面是相同的代码。
//Java Program to perform Assignment Operator
import java.util.*;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create instance of the Scanner Class
Scanner s=new Scanner(System.in);
while(true)
{
System.out.println("");
System.out.println("Choose the operation you want to perform ");
System.out.println("Choose 1 for += ");
System.out.println("Choose 2 for -= ");
System.out.println("Choose 3 for *= ");
System.out.println("Choose 4 for /= ");
System.out.println("Choose 5 for %= ");
System.out.println("Choose 6 for EXIT");
int n = s.nextInt();
switch(n)
{
case 1:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int x = s.nextInt();
System.out.print("Enter the second number : ");
int y = s.nextInt();
System.out.println("Initial value of x is " + x);
x+=y;
System.out.println("The value of x after += is " + x);
break;
case 2:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int p = s.nextInt();
System.out.print("Enter the second number : ");
int q = s.nextInt();
System.out.println("Initial value of p is " + p);
p-=q;
System.out.println("The value of p after -= is " + p);
break;
case 3:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int a = s.nextInt();
System.out.print("Enter the second number : ");
int b = s.nextInt();
System.out.println("The initial value of a is " + a);
a*=b;
System.out.println("The value of a after *= is " + a);
break;
case 4:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int c = s.nextInt();
System.out.print("Enter the second number : ");
int d = s.nextInt();
System.out.println("Initial value of c is " + c);
c/=d;
System.out.println("The value of c after /= is " + c);
break;
case 5:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int e = s.nextInt();
System.out.print("Enter the second number : ");
int f = s.nextInt();
System.out.println("Initial value of e is " + e);
e%=f;
System.out.println("The value of e after %= is " + e);
break;
case 6:
System.exit(0);
}
}
}
}
选择要执行的操作
选择 1 代表+=
选择 2 代表-=
选择 3 代表*=
选择 4 代表/=
选择 5 代表%=
选择 6 代表退出
1
输入两个数字执行操作
输入第一个数字:
输入第二个数字:
x 的初始值为 5
x 在+=之后的值为 9
选择要执行的操作 要执行
选择 1 代表+=
选择 2 代表-=
选择 3 代表*=
选择 4 代表/=
选择 5 代表%=
选择 6 代表退出
2
输入两个数字执行操作
输入第一个数字:
输入第二个数字:
p 的初始值为 4
p 在-=之后的值为 1
选择要执行的操作【T25 +=
选择 2 代表-=
选择 3 代表=
选择 4 代表/=
选择 5 代表%=
选择 6 代表 EXIT
3
输入两个数字执行操作
输入第一个数字:
输入第二个数字:
a 的初始值为 4
a 在=之后的值为 20
选择你要执行的操作
选择 1 代表+ -=
选择 3 代表*=
选择 4 代表/=
选择 5 代表%=
选择 6 代表 EXIT
4
输入两个数字执行操作
输入第一个数字:
输入第二个数字:
c 的初始值为 8
c 在/=之后的值为 1
选择要执行的操作
选择 1 代表+=
选择 2 代表-=。 对于*=
选择 4 对于/=
选择 5 对于%=
选择 6 对于 EXIT
5
输入两个数字执行操作
输入第一个数字:
输入第二个数字:
e 的初始值为 7
e 在%=之后的值为 1
选择要执行的操作
选择 1 对于+=
Java 程序：求商和余数
原文：https://www.studytonight.com/java-programs/java-program-to-find-quotient-and-remainder
在本教程中，我们将学习如何通过接受用户的输入来找到商和余数。但是在继续之前，如果你不熟悉 java 中算术运算符的概念，那么一定要查看关于 Java 中运算符的文章。
输入:输入第一个数字:6
输入第二个数字:2
输出:
6 和 2 的商是 3
6 和 2 的余数是 0
上述问题可以通过以下方式解决:
方法 1:当值被预定义时
方法 2:当值由用户定义时
让我们分别看看这些方法。
程序 1:求商和余数
在这个程序中，当两个数字是用户定义的时，我们将找到它们的商和余数。
算法:
- 开始
- 声明两个变量。
- 初始化变量。
- 用除法运算符求商。
- 使用模运算符求余数。
- 显示商和余数。
- 停下来。
下面是相同的代码。
//Java Program to find the quotient and remainder
public class Main
{
public static void main(String[] args)
{
int num1 = 19, num2 = 4; //Declare and initialize the numbers
System.out.println("The entered number is: "+num1);
System.out.println("The entered number is: "+num1);
int quotient = num1 / num2; //Find quotient
int remainder = num1 % num2; //Find Remainnder
System.out.println("After division the quotient and remainder are: ");
//Print the quotient and remainder
System.out.println("The quotient is: " + quotient);
System.out.println("The remainder is: " + remainder);
}
}
输入的数字是:19
输入的数字是:19
除法后的商和余数是:
商是:4
余数是:3
程序 2:求商和余数
在这个程序中，当两个数字是用户定义的时，我们将找到它们的商和余数。这意味着，在这里，首先我们将要求用户初始化数字，然后我们将找到商和余数。
算法:
- 开始
- 创建 Scanner 类的实例以从用户处获取输入。
- 声明两个变量。
- 请用户初始化它。
- 用除法运算符求商。
- 使用模运算符求余数。
- 显示商和余数。
- 停下来。
下面是相同的代码。
//Java Program to find the quotient and remainder
import java.util.*;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create object of Scanner class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the numbers ");
System.out.println("Enter the first number: ");
int num1=sc.nextInt(); //Initialize the number
System.out.println("Enter the second number: ");
int num2=sc.nextInt(); //Initialize the number
int quotient = num1 / num2;
int remainder = num1 % num2;
System.out.println("After division the quotient and remainder are:");
//Print the Quotient
System.out.println("The quotient is: " + quotient);
System.out.println("The remainder is: " + remainder);
}
}
输入数字
输入第一个数字:19
输入第二个数字:7
除法后商和余数为:
商为:2
余数为:5
程序 3:求商和余数
在这个程序中，我们将使用用户定义的方法，用用户定义的输入来求商和余数。
算法:
- 开始
- 创建 Scanner 类的实例以从用户处获取输入。
- 声明两个变量。
- 请用户初始化它。
- 调用用户定义的方法来求商和余数。
- 用除法运算符求商。
- 使用模运算符求余数。
- 显示商和余数。
- 停下来。
下面是相同的代码。
//Java Program to find the quotient and remainder
import java.util.*;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create object of Scanner class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the numbers ");
System.out.println("Enter the first number: ");
int num1=sc.nextInt(); //Initialize the number
System.out.println("Enter the second number: ");
int num2=sc.nextInt(); //Initialize the number
findQuotient(num1,num2);
}
//user defined method
static void findQuotient(int num1, int num2)
{
int quotient=num1/num2;
int remainder=num1%num2;
//display result
System.out.println("The quotient of "+num1+" and "+num2+" is "+quotient);
System.out.println("The remainder of "+num1+" and "+num2+" is"+remainder);
}
}
输入数字
输入第一个数字:9
输入第二个数字:7
9 和 7 的商是 1
9 和 7 的余数是 2
Java 程序：检查偶数和奇数
原文：https://www.studytonight.com/java-programs/java-program-to-check-even-and-odd-number
在本教程中，我们将学习如何检查输入的数字是偶数还是奇数。偶数是能被 2 整除的数，不能被 2 整除的数称为奇数。这里，在这个程序中，我们将检查这个数是否能被 2 整除。如果能整除，那么它就是偶数，如果不能整除，那么它就是奇数。但是在继续之前，如果你不熟悉 java 中条件语句的概念，那么一定要查看条件语句上的文章。
输入:输入数字:6
输出:输入的数字为偶数。
程序 1:检查数字是偶数还是奇数
在这个程序中，我们将看到当数字是用户定义的时，如何检查数字是偶数还是奇数。这意味着，这里我们将首先要求用户输入数字，然后我们将检查输入的数字是偶数还是奇数。
算法
-
开始
-
创建一个 Scanner 类的对象，从用户那里获取输入。
-
声明一个变量来存储数字。
-
要求用户初始化数字。
-
检查这个数是否能被 2 整除。
-
如果数字能被 2 整除，那么输入的数字就是偶数。
-
如果输入的数字不能被 2 整除，那么输入的数字就是奇数。
-
显示输出。
-
停下来。
下面的例子说明了上述算法的实现。
/*Java Program to check whether a number is even or odd*/
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
//To take input from the user
//Create an object of scanner class
Scanner input = new Scanner(System.in);
int num; //Declare a variable
System.out.println("Enter a number:");
num = input.nextInt();
//If number is divisible by 2 then it's an even number
//else odd number
if ( num % 2 == 0 )
System.out.println("The entered number is even");
else
System.out.println("The entered number is odd");
}
}
输入数字:6
输入的数字是奇数
程序 2:检查数字是偶数还是奇数
在这个程序中，我们将看到如何使用三进制运算符检查数字是偶数还是奇数。这意味着，首先我们将要求用户输入数字，然后使用三进制运算符检查输入的数字是偶数还是奇数。
算法:
-
开始
-
创建一个 Scanner 类的对象，从用户那里获取输入。
-
声明一个变量来存储数字。
-
要求用户初始化数字。
-
使用三进制运算符检查输入的数字是偶数还是奇数。
-
如果输入的数字能被 2 整除，那么它就是偶数，否则就是奇数。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
/*Java Program to check whether a number is even or odd*/
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
//To take input from the user
//Create an object of scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter a number: ");
int num = sc.nextInt();
//Use Ternary Operator to check
String check = (num % 2 == 0) ? "even" : "odd";
System.out.println("The entered number "+ num + " is: " + check);
}
}
输入数字:5
输入的数字 5 是:奇数
程序 3:检查数字是偶数还是奇数
在这个程序中，我们将看到如何使用按位异或来检查数字是偶数还是奇数。使用这种方法的逻辑是，偶数的按位异或运算将数字的值增加 1，否则，如果值为奇数，它将数字的值减少 1。
算法
-
开始
-
创建一个 Scanner 类的对象，从用户那里获取输入。
-
声明一个变量来存储数字。
-
要求用户初始化数字。
-
使用按位异或检查数字是偶数还是奇数。
-
如果与 1 按位异或后的数等于原数+ 1，则为偶数。
-
如果不相等，那么它就是一个奇数。
-
显示结果。
-
停下来。
下面的例子说明了上述算法的实现。
/*Java Program to check whether a number is even or odd*/
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
//To take input from the user
//Create an object of scanner class
Scanner sc = new Scanner(System.in);
System.out.println("Enter a number: ");
int num = sc.nextInt();
//Check Using Bitwise XOR
if ((num ^ 1) == num + 1)
{
System.out.println("The entered number "+ num +" is Even");
}
else
{
System.out.println("The entered number "+ num +" is Odd");
}
}
}
输入数字:52
输入的数字 52 为偶数
Java 程序：检查字符串是否为空或null
原文：https://www.studytonight.com/java-programs/java-program-to-check-if-a-string-is-empty-or-null
在本教程中，我们将学习如何检查字符串是否为空。这可以通过各种方法来实现，比如如果输入的字符串长度为 0，那么它就是一个空字符串。我们还可以使用各种预定义的方法，如 equals()，isEmpty()，等来检查字符串是否为空。但是在进一步深入之前，如果你不熟悉字符串的概念，那么一定要查看 Java 中Strings的文章。
输入:输入字符串:苹果
输出:输入的字符串为空？:假
程序 1:检查字符串是否为空
在这个程序中，我们将学习如何使用关系运算符检查字符串是空的还是空的。
算法:
-
开始
-
声明一个字符串。
-
用一些值初始化它。
-
使用关系运算符检查输入的字符串是否为空。
-
显示结果。
-
声明另一个字符串并将其初始化为 null。
-
使用关系运算符检查输入的字符串是否为空。
-
显示结果。
-
停下来。
下面的例子说明了上述算法的实现。
/*Java Program to check if a string is empty or null*/
public class Main
{
public static void main(String[] args)
{
String str1 = "Study Tonight";
String str2 = null;
System.out.println("Is string: " + str1 +" empty or null? " + isEmptyOrNull(str1));
System.out.println("Is string: " + str2 + " empty or null? "+ isEmptyOrNull(str2));
}
public static boolean isEmptyOrNull(String str)
{
// use == relational operator and return the result
if (str == null)
return true;
else
return false;
}
}
字符串:今晚学习是空的还是空的？false
字符串:null 是空的还是 null？真实的
程序 2:检查字符串是否为空
在这个程序中，我们将学习如何使用关系运算符或 is empty()检查字符串是空的还是 null。
算法:
-
开始
-
声明字符串
-
用一些值初始化它。
-
使用关系运算符或 isEmpty()检查输入的字符串是否为空。
-
显示结果。
-
声明另一个字符串并将其初始化为 null。
-
使用关系运算符或 isEmpty()检查输入的字符串是否为空。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
/*Java Program to check if a string is empty or null*/
public class Main
{
public static void main(String[] args)
{
String str1 = "Study Tonight";
System.out.println("Entered String is: "+str1);
System.out.println("Is the entered string empty or null? "+str1 == null || str1.isEmpty()); //false
String str2 = "";
System.out.println("Entered String is: "+str2);
System.out.println("Is the entered string empty or null? "
+str2 == null || str2.isEmpty()); // true
}
}
输入字符串为:今晚学习
假
输入字符串为:
真
程序 3:检查字符串是否为空
在这个程序中，我们将学习如何使用 length()方法检查字符串是否为空。如果长度=0，则它是空字符串。
算法:
-
开始
-
声明字符串
-
用一些值初始化它。
-
使用 length()检查输入的字符串是否为空。
-
如果输入的字符串长度为 0，则为空字符串。
-
显示结果。
-
声明另一个字符串并将其初始化为 null。
-
使用 length()检查输入的字符串是否为空。
-
如果输入的字符串长度为 0，则为空字符串。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
/*Java Program to check if a string is empty or null*/
public class Main
{
public static void main(String[] args)
{
String str1 = "Study Tonight";
System.out.println("Entered String is: "+str1);
System.out.println("Is the entered string empty or null? " +str1 == null || str1.length() == 0); //false
String str2 = "";
System.out.println("Entered String is: "+str2);
System.out.println("Is the entered string empty or null? "
+str2 == null || str2.length() == 0); // true
}
}
输入字符串为:今晚学习
假
输入字符串为:
真
程序 4:检查字符串是否为空
在这个程序中，我们将学习如何检查字符串是否为空。在这里，我们将使用。方法对空字符串进行相等性检查。
算法:
-
开始
-
声明一个字符串。
-
用一些值初始化它。
-
使用 equals()方法对空字符串进行相等性检查。
-
显示结果。
-
声明另一个字符串并将其初始化为 null。
-
使用 equals()方法对空字符串进行相等性检查。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
/*Java Program to check if a string is empty or null*/
public class Main
{
private static String EMPTY = "";
public static void main(String[] args)
{
String str1 = "Study Tonight";
System.out.println("Entered String is: "+str1);
System.out.println("Is the entered string empty or null? ");
System.out.println(str1 == null || EMPTY.equals(str1)); // false
System.out.println(str1 == null || str1.equals(EMPTY)); // false
String str2 = "";
System.out.println("Entered String is: "+str2);
System.out.println("Is the entered string empty or null? ");
System.out.println(str2 == null || EMPTY.equals(str2)); // true
System.out.println(str2 == null || str2.equals(EMPTY)); // true
}
}
输入的字符串是:今晚学习
输入的字符串是空的还是空的？
假
假
输入的字符串是:
输入的字符串是空的还是空的？
真
真
Java 程序：使用递归求一个数的阶乘
在本教程中，我们将学习如何使用递归函数找到一个数的阶乘。递归函数是调用自身的函数。但是在继续之前，如果你不熟悉 java 中方法的基本概念，那么一定要查看主题为 java 中方法的文章。
输入:输入数字:5
输出:输入数字的阶乘为:120
程序 1:用递归求一个数的阶乘
在这个程序中，我们将使用带有用户定义值的递归找到一个数的阶乘。这里，我们将要求用户输入一个值，然后通过递归调用函数来计算阶乘。
算法
- 开始
- 声明一个变量来存储一个数字。
- 要求用户初始化数字。
- 检查是否可以计算阶乘。
- 如果数字大于等于 0，则调用递归函数来计算输入数字的阶乘。
- 如果数字小于 0，则打印无法计算阶乘的消息。
- 如果输入的数字是 0 或 1，则返回 1。
- 如果输入的数字不是 0 或 1，则通过递归调用相同的方法计算阶乘。
- 返回结果。
- 打印输入数字的阶乘。
- 停止
下面是相同的 Java 语言代码。
/*Java Program to find factorial of a number using Recursive Function*/
import java.util.Scanner;
public class Main
{
//Driver Code
public static void main(String[] args)
{
//Take input from the user
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number :");
int num = sc.nextInt(); //Input the number
if(num>=0)
{
//Call a recursive function to find the factorial
int factorial=findFactorial(num);
System.out.println("The factorial of the entered the number is :"+factorial);
}
else
{
System.out.println("Factorial not possible.");
System.out.println("Please enter valid input.");
}
}
//Recursive Function to Find the Factorial of a Number
public static int findFactorial(int num)
{
if(num==0)
return 1;
else if(num==1)
return 1;
else
return num*findFactorial(num-1);
}
}
输入数字:10
输入数字的阶乘为:3628800
程序 2:用递归求一个数的阶乘
在这个程序中，我们将使用带有预定义值的递归找到一个数的阶乘。这里，要计算阶乘的数字已经在程序中给出，我们的任务是通过递归调用函数来计算阶乘。
算法
- 开始
- 声明一个变量来存储一个数字。
- 初始化数字。
- 检查是否可以计算阶乘。
- 如果数字大于等于 0，则调用递归函数来计算输入数字的阶乘。
- 如果数字小于 0，则打印无法计算阶乘的消息。
- 如果输入的数字是 0 或 1，则返回 1。
- 如果输入的数字不是 0 或 1，则通过递归调用相同的方法计算阶乘。
- 返回结果。
- 打印输入数字的阶乘。
- 停止
下面是相同的 Java 语言代码。
/*Java Program to find factorial of a number using Recursive Function*/
public class Main
{
//Driver Code
public static void main(String[] args)
{
int num=5;
System.out.println("The entered number is :"+num);
if(num>=0)
{
//Call a recursive function to find the factorial
int factorial=findFactorial(num);
System.out.println("The factorial of the entered number is :"+factorial);
}
else
{
System.out.println("Factorial not possible.");
System.out.println("Please enter valid input.");
}
}
//Recursive Function to Find the Factorial of a Number
public static int findFactorial(int num)
{
if(num==0)
return 1;
else if(num==1)
return 1;
else
return num*findFactorial(num-1);
}
}
输入的数字是:5
输入的数字的阶乘是:120
Java 程序：显示上三角矩阵
原文：https://www.studytonight.com/java-programs/java-program-to-display-upper-triangular-matrix
在本教程中，我们将学习如何显示上三角矩阵。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
下面是同样的图示。
输入:输入矩阵元素:
1 2 3
4 5 6
7 8 9
输出:上三角矩阵为:
1 2 3
0 5 6
0 0 9
程序 1:显示上三角矩阵
在下面的程序中，我们将看到当值由用户定义时，如何显示上三角矩阵。在这里，我们将要求用户输入矩阵元素，然后我们将只显示那些行数大于列数的矩阵元素。
算法
- 开始
- 声明变量来存储行数和列数。
- 要求用户初始化行和列。
- 检查行数和列数是否相等。
- 如果不相等，则显示一条消息，说明行数和列数应该相等。
- 如果相等，则声明一个矩阵。
- 要求用户初始化矩阵元素。
- 打印原始矩阵。
- 调用一个方法来显示上三角矩阵。
- 使用循环迭代元素。
- 将 0 分配给行数大于列数的元素。
- 打印结果矩阵。
- 停下来。
下面是相同的代码。
// Java Program to print the upper triangular matrix
import java.util.*;
public class Main
{
// Print the matrix
public static void printMatrix(int[][] arr)
{
int m = arr.length; //For Rows
int n = arr[0].length; //For columns
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
//Display the upper triangular matrix
public static void upperTriangularMatrix(int arr[][])
{
int m = arr.length;
int n = arr[0].length;
if (m != n)
{
System.out.println("Matrix entered should be a Square Matrix");
System.out.println("Try Again..");
return;
}
else
{
// looping over the whole matrix
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i > j)
{
arr[i][j] = 0;
}
}
}
System.out.println( "Upper Triangular Matrix is : ");
// printing the upper triangular matrix
printMatrix(arr);
}
}
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
int m,n; //Declare variables for rows and columns
System.out.println("Enter the number of rows: ");
m=sc.nextInt();
System.out.println("Enter the number of columns: ");
n=sc.nextInt();
System.out.println("Enter the matrix elements: ");
int arr[][] = new int[m][n]; //Declare the matrix
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
arr[i][j]=sc.nextInt(); //Initialize the matrix
}
}
//Print Original Matrix
System.out.println( "Original Matrix is : ");
printMatrix(arr);
// calling to display the upper triangular matrix
upperTriangularMatrix(arr);
}
}
输入行数:3
输入列数:3
输入矩阵元素:1 2 8 7 5 4 3 9
原始矩阵为:
1 2 8
7 6 5
4 3 9
上三角矩阵为:
1 2 8
0 6 5
0 0 9
程序 2:显示上三角矩阵
在下面的程序中，我们将看到如何显示预定义值时的上三角矩阵。这里，矩阵的元素是在程序中预先定义的。因此，我们将只显示那些行数大于列数的矩阵元素。
算法
- 开始
- 声明变量来存储行数和列数。
- 初始化行和列。
- 检查行数和列数是否相等。
- 如果不相等，则显示一条消息，说明行数和列数应该相等。
- 如果相等，则声明一个矩阵。
- 初始化矩阵元素。
- 打印原始矩阵。
- 调用一个方法来显示上三角矩阵。
- 使用循环迭代元素。
- 将 0 分配给行数大于列数的元素。
- 打印结果矩阵。
- 停下来。
下面是相同的代码。
// Java Program to print the upper triangular matrix
import java.io.*;
public class Main
{
// Print the matrix
public static void printMatrix(int[][] arr)
{
int m = arr.length; //For Rows
int n = arr[0].length; //For columns
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
//Display the upper triangular matrix
public static void upperTriangularMatrix(int arr[][])
{
int m = arr.length;
int n = arr[0].length;
if (m != n)
{
System.out.println("Matrix entered should be a Square Matrix");
System.out.println("Try Again..");
return;
}
else
{
// looping over the whole matrix
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i > j)
{
arr[i][j] = 0;
}
}
}
System.out.println( "Upper Triangular Matrix is : ");
// printing the upper triangular matrix
printMatrix(arr);
}
}
public static void main(String[] args)
{
int arr[][] = { { 8, 7, 6 }, { 4, 2, 5 }, { 7, 9, 8 } };
//Print Original Matrix
System.out.println( "Original Matrix is : ");
printMatrix(arr);
// calling to display the upper triangular matrix
upperTriangularMatrix(arr);
}
}
原矩阵为:
8 7 6
4 2 5
7 9 8
上三角矩阵为:
8 7 6
0 2 5
0 0 8
Java 程序：确定给定矩阵是否为稀疏矩阵
在本教程中，我们将学习如何确定给定的矩阵是否是稀疏矩阵。如果一个矩阵的大部分元素都是 0，那么这个矩阵就是稀疏矩阵。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
下面是同样的图示。
输入:输入矩阵元素:
1 4 0
0 0 0
4 0 0
输出:是稀疏矩阵。
程序 1:确定给定的矩阵是否是稀疏矩阵
在这个程序中，我们将学习当值是用户定义的时，如何确定给定的矩阵是否是稀疏矩阵。在这里，我们将要求用户输入值，然后，我们将检查给定的矩阵是否是稀疏矩阵。
算法
- 开始
- 声明变量来存储矩阵的大小。
- 要求用户初始化行数和列数。
- 声明一个矩阵。
- 要求用户初始化矩阵的元素。
- 打印原始矩阵
- 声明一个变量来存储矩阵的大小。
- 声明一个变量来计算矩阵中 0 个元素的数量。
- 使用循环计算所有的零元素。
- 如果发现任何 0 元素，则增加计数。
- 检查计数是否大于大小的一半。
- 如果更大，则将其打印为稀疏矩阵。
- 否则打印它不是稀疏矩阵。
- 停下来。
下面是相同的代码。
//Java Program to check whether the given matrix is sparse or not*/
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
// declare variables
int m, n;
// To take input from the user
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number of rows ");
// Initialize the number of rows
m = sc.nextInt();
System.out.println("Enter the number of columns ");
// Initialize the number of columns
n = sc.nextInt();
// declare a mxn order array
int a[][] = new int[m][n];
System.out.println("Enter all the values of matrix ");
// Initialize the matrix elements
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
a[i][j] = sc.nextInt();
}
}
System.out.println("Original Matrix:");
// print the original matrix
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(a[i][j] + " ");
}
System.out.println("");
}
int size= m*n; //Stores the size of the matrix
int count=0; //Variable to check for the number of 0 elements
//Loop to count all zero element present in matrix
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
if(a[i][j] == 0) //Check if element is 0 or not
count++; //Increment the count if 0 element is found
}
}
if(count>(size/2))
System.out.println("It is a sparse matrix");
else
System.out.println("It is not a sparse matrix");
}
}
输入行数 3
输入列数 3
输入矩阵 1 的所有值 2 0 0 0 0 0 0
原始矩阵:
1 2 0
0 0 0
0 0 0
它是一个稀疏矩阵
程序 2:确定给定的矩阵是否是稀疏矩阵
在这个程序中，我们将学习当值被预定义时，如何确定给定的矩阵是否是稀疏矩阵。这里，矩阵的元素是在程序中预先定义的。因此，基于该矩阵的值，我们将检查给定的矩阵是否是稀疏矩阵。
算法
- 开始
- 声明并初始化矩阵。
- 声明变量来存储矩阵的行数和列数。
- 打印原始矩阵。
- 声明一个变量来存储矩阵的大小。
- 声明一个变量来计算矩阵中 0 个元素的数量。
- 使用循环计算所有的零元素。
- 如果发现任何 0 元素，则增加计数。
- 检查计数是否大于大小的一半。
- 如果更大，则将其打印为稀疏矩阵。
- 否则打印它不是稀疏矩阵。
- 停下来。
下面是相同的代码。
//Java Program to check whether the given matrix is sparse or not*/
public class Main
{
public static void main(String[] args)
{
// declare and initialize a matrix
int a[][] = {{ 2, 9, 8 }, { 7, 6, 4 }, { 3, 9, 2 } };
int m=a.length; //Stores the number of rows in a matrix
int n=a[0].length; //Stores the number of columns in a matrix
// print the original matrix
System.out.println("Original Matrix:");
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(a[i][j] + " ");
}
System.out.println("");
}
int size= m*n; //Stores the size of the matrix
int count=0; //Variable to check for the number of 0 elements
//Loop to count all zero element present in matrix
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
if(a[i][j] == 0) //Check if element is 0 or not
count++; //Increment the count if 0 element is found }
}
if(count>(size/2))
System.out.println("It is a sparse matrix");
else
System.out.println("It is not a sparse matrix");
}
}
原始矩阵:
2 9 8
7 6 4
3 9 2
它不是稀疏矩阵
Java 程序：接受M*N阶矩阵并交换对角线
在本教程中，我们将学习如何接受 M*N 阶的矩阵并交换对角线。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:输入矩阵元素:
1 2 3
6 5 4
7 8 9
输出:
3 2 1
4 5 6
9 8 7
程序 1:交换矩阵的对角线
在这个程序中，我们将看到如何接受 M*N 阶的矩阵，并用用户定义的值交换对角线。
算法
- 开始
- 声明矩阵大小的变量。
- 要求用户初始化矩阵行和列
- 检查行数和列数是否相等。
- 如果相等，则要求用户初始化矩阵。
- 打印原始矩阵。
- 交换对角线元素。
- 打印互换的矩阵。
- 如果行和列不相等，则打印相同的消息。
- 停止
下面是相同的代码。
//Java Program to interchange the diagonals*/
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
// declare variables
int m, n, temp;
// To take input from the user
Scanner sc = new Scanner(System.in);
System.out.println("Enter number of rows ");
// Initialize the number of rows
m = sc.nextInt();
System.out.println("Enter number of columns ");
// Initialize the number of columns
n = sc.nextInt();
// declare a mxn order array
int a[][] = new int[m][n];
// Interchange the diagonals only when it is a square matrix
if (m == n)
{
System.out.println("Enter all the values of matrix ");
// Initialize the matrix elements
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
a[i][j] = sc.nextInt();
}
}
System.out.println("Original Matrix:");
// print the original matrix
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println("");
}
// Interchange the diagonals by swapping
for (int j = 0; j < m; j++)
{
temp = a[j][j];
a[j][j] = a[j][n - 1 - j];
a[j][n - 1 - j] = temp;
}
System.out.println("After interchanging diagonals of matrix ");
// print interchanged matrix
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println("");
}
}
else
{
System.out.println("Rows not equal to columns");
}
}
}
输入行数 3
输入列数 3
交换矩阵对角线后输入矩阵 1 2 3 4 5 6 7 8 9
原始矩阵:
1 2 3
4 5 6
7 8 9
交换矩阵对角线后
3 2 1
4 5 6
9 8 7
程序 2:交换矩阵的对角线
在这个程序中，我们将看到如何接受 M*N 阶的矩阵，并将对角线与预定义的值互换。
算法
- 开始
- 声明并初始化矩阵大小。
- 检查行数和列数是否相等。
- 如果相等，则初始化矩阵的元素。
- 打印原始矩阵。
- 调用一个方法来交换对角线。
- 交换对角线元素。
- 打印互换的矩阵。
- 如果行和列不相等，则打印相同的消息。
- 停止
下面是相同的代码。
//Java Program to interchange the diagonals*/
import java.util.*;
public class Main
{
//Method to interchange the diagonals
static void interchangeDiagonals(int arr[][])
{
int temp=0;
int m=arr.length; //Variable to store the number of rows
int n=arr[0].length; //Variable to store the number of columns
System.out.println("Original Matrix:");
// print the original matrix
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println("");
}
// Interchange the diagonals by swapping
for (int j = 0; j <m; j++)
{
temp = arr[j][j];
arr[j][j] = arr[j][n - 1 - j];
arr[j][n - 1 - j] = temp;
}
System.out.println("After interchanging diagonals of matrix ");
// print interchanged matrix
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println("");
}
}
public static void main(String[] args)
{
// declare variables
int rows=3, columns=3;
// Interchange the diagonals only when it is a square matrix
if (rows == columns)
{
int arr[][] = { { 2, 9, 8 }, { 7, 6, 4 }, { 3, 9, 2 } }; //Matrix Declaration
interchangeDiagonals(arr);
}
else
{
System.out.println("Rows not equal to columns");
}
}
}
原始矩阵:
2 9 8
7 6 4
3 9 2
交换矩阵对角线后
8 9 2
7 6 4
2 9 3
Java 程序：计算给定矩阵的迹和范数
在本教程中，我们将学习如何找到矩阵的迹和范数。矩阵中的迹定义为对角元素的和，范数定义为矩阵元素平方和的平方根。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
下面是如何找到矩阵轨迹的图示。
下面是如何求矩阵范数的图示。
输入:输入矩阵元素:5 4 3 1 2 6 9 8 7
输出:矩阵的轨迹为:14.0
矩阵的范数为:16.88
程序 1:寻找矩阵的迹和范数
在这个程序中，我们将看到当值是用户定义的时，如何找到矩阵的迹和范数。
算法
- 开始
- 为行和列声明变量。
- 要求用户初始化行和列。
- 声明一个矩阵。
- 要求用户初始化矩阵元素。
- 打印原始矩阵。
- 声明两个变量来计算矩阵的迹和范数。
- 将这些变量初始化为零。
- 使用两个 for 循环来计算矩阵的轨迹。
- 使用第一个 for 循环遍历行。
- 使用第二个 for 循环遍历列。
- 使用 if 条件检查行号和列号是否相同。
- 如果相同，则计算每次迭代中的跟踪。
- 打印矩阵的跟踪值。
- 现在，要再次计算矩阵的范数，循环使用两个。
- 使用第一个 for 循环遍历行。
- 使用第二个 for 循环遍历列。
- 计算每个数字的平方，并在每次迭代中更新平方变量。
- 现在，求上面计算的平方的平方根。
- 打印结果。
- 停止
下面的程序演示了如何找到矩阵的迹和范数。
/*JAVA PROGRAM TO FIND THE TRACE AND NORMAL OF A MATRIX*/
import java.util.*;
public class Main
{
public static void main(String []args)
{
///Take input from the user
Scanner sc=new Scanner(System.in);
int m,n; //Matrix Row and Column Declaration
System.out.println("Enter the number of rows: \n");
m=sc.nextInt(); //Matrix Row Initialization
System.out.println("Enter the number of column: \n");
n=sc.nextInt(); //Matrix Column Initialization
int arr[][]=new int[10][10]; //Matrix Size Declaration
System.out.println("Enter the elements of the matrix: ");
for(int i=0;i<m;i++) //Matrix Elements Initialization
{
for(int j=0;j<n;j++)
{
arr[i][j]=sc.nextInt();
}
}
//Print the original Matrix
System.out.println("The elements in the original matrix are: ");
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
System.out.print(arr[i][j]+" "); //Print the matrix elements
}
System.out.println("");
}
double sum=0; //Declare and initialize the trace variable
double square=0; //Declare and initialize the normal variable
//Find the trace of the matrix
System.out.println("The Trace of the above matrix is ");
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
if(i == j)
{
sum = sum + (arr[i][j]); //Calculate the trace in each iteration
}
}
}
System.out.println(sum); //Print the trace of the matrix
//Find the normal of the matrix
System.out.println("The Normal of the above matrix is ");
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
square = square + (arr[i][j])*(arr[i][j]); //Calculate the normal in each iteration
}
}
double result = Math.sqrt(square);
System.out.println(result); //Print the normal
}
}
输入行数:3
输入列数:3
输入矩阵的元素:1 2 3 4 5 6 7 8 9
原矩阵中的元素为:
1 2 3
4 5 6
7 8 9
上述矩阵的迹为
15.0
上述矩阵的范数为
16.881943016134134
程序 2:寻找矩阵的迹和范数
在这个程序中，我们将看到当值被预定义时，如何找到矩阵的迹和范数。
算法
- 开始
- 声明并初始化矩阵。
- 打印原始矩阵。
- 调用一个方法来计算矩阵的轨迹。
- 在该方法中声明一个变量和，并将其初始化为 0。
- 当对角线值遇到时，增加总和。
- 显示总和。
- 现在，调用一个方法来计算矩阵的范数。
- 声明一个变量 square 并将其初始化为 0。
- 计算每个数字的平方，并在每次迭代中更新平方变量。
- 现在，求上面计算的平方的平方根。
- 打印结果。
- 停止
下面的程序演示了如何找到矩阵的迹和范数。
/*Java Program to find the trace and normal of a matrix*/
import java.io.*;
public class Main
{
//To Find the normal of a matrix
public static void findNormal(int[][] arr)
{
double square = 0, result = 0;
System.out.println("The Normal of the above matrix is ");
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[0].length; j++)
{
square = square + (arr[i][j])*(arr[i][j]);
}
}
result = Math.sqrt(square);
System.out.println(result);
}
//To Find the trace of a matrix
public static void findTrace(int[][] arr)
{
double sum = 0;
System.out.println("The Trace of the above matrix is ");
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[0].length; j++)
{
if(i == j)
{
sum = sum + (arr[i][j]);
}
}
}
System.out.println(sum);
}
// Driver code
public static void main(String args[]) throws IOException
{
int arr[][]
= { { 2, 9, 8 }, { 7, 6, 4 }, { 3, 9, 2 } }; //Matrix Declaration and Initialization
System.out.println("Original Matrix");
for(int i = 0; i < arr.length; i++)
{
for(int j = 0; j < arr[0].length; j++)
{
System.out.print(arr[i][j]+ " ");
}
System.out.println();
}
System.out.println();
findTrace(arr); //Find the Trace of the Matrix
System.out.println();
findNormal(arr); //Find the Normal of the Matrix
}
}
原始矩阵
2 9 8
7 6 4
3 9 2
T5】上述矩阵的迹为
10.0
上述矩阵的范数为
18 . 36960 . 499999999606
Java 程序：计算单利
原文：https://www.studytonight.com/java-programs/java-program-to-find-simple-interest
在本教程中，我们将学习如何在给定本金、利率和时间段的情况下找到单利。简单利息是计算贷款利息费用最简单的方法。但是在继续之前，如果你不熟悉 java 中算术运算符的概念，那么一定要查看关于 Java 中运算符的文章。
输入:输入本金金额:6200
输入汇率:11
输入时间段:2
输出:
单利:1364.0
程序 1:找到对 Java 的单利
在这个程序中，我们将看到当值是用户定义的时，如何使用公式找到简单的兴趣。这意味着，首先我们将要求用户初始化变量，然后我们将使用公式找到简单的兴趣。
算法:
-
开始
-
创建 Scanner 类的实例，从用户处获取输入。
-
为本金、利率和时间段声明变量。
-
要求用户初始化这些变量。
-
用公式计算单利。
-
打印简单利息的值。
-
停止
下面是寻找单利的 Java 代码。
//Java Program to find the simple interest
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
//Take input from the user
//Create an instance of Scanner class
Scanner sc = new Scanner(System.in);
//Declare variables
float p, r, t, si;
System.out.println("Enter the Principal : ");
p = sc.nextFloat(); //Initialize the variables
System.out.println("Enter the Rate of interest : ");
r = sc.nextFloat(); //Initialize the variables
System.out.println("Enter the Time period : ");
t = sc.nextFloat(); //Initialize the variables
sc.close();
//Calculate the simple interest
si = (p * r * t) / 100;
//Print the simple interest
System.out.println("Simple Interest is: " +si);
}
}
输入本金:2000
输入利率:5
输入时间段:2
单利为:200.0
程序 2:找到对 Java 的单利
在这个程序中，我们将找到本金、利率和预定义值的时间段。
算法:
-
开始
-
声明本金、利率和时间段的变量。
-
初始化变量。
-
用公式计算单利。
-
打印简单利息。
-
停止
下面是寻找单利的 Java 代码。
//Java Program to find the simple interest
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
//Declare and Initialize the Principle, Rate and Time Period
float P = 1500, R = 10, T = 2;
System.out.println("The entered principle amount is = " + P);
System.out.println("The entered rate is = " + R);
System.out.println("The entered time period is " + T);
// Calculate simple interest
float SI = (P * T * R) / 100;
//Print the simple interest
System.out.println("Simple interest = " + SI);
}
}
录入本金金额= 1500.0
录入利率= 10.0
录入时间段为 2.0
单利= 300.0
程序 3:找到对 Java 的单利
在这个程序中，我们将通过使用用户定义的函数来找到本金、利率和时间段。这里，我们将使用用户定义的函数来计算简单利息。
算法:
-
开始
-
创建 Scanner 类的实例，从用户处获取输入。
-
为本金、利率和时间段声明变量。
-
要求用户初始化这些变量。
-
调用一个方法来计算单利。
-
用公式计算单利。
-
打印简单利息的值。
-
停止
下面是寻找单利的 Java 代码。
//Java Program to find the simple interest
import java.util.Scanner;
public class Main
{
//User-defined program to find the simple interest
public static float simpleInterest(float principal, float rate, float time)
{
float interest = (principal*rate*time)/100;
return interest;
}
public static void main(String args[])
{
//Take input from the user
//Create an instance of Scanner class
Scanner sc = new Scanner(System.in);
//Declare variables
float p, r, t;
System.out.println("Enter the Principal : ");
p = sc.nextFloat(); //Initialize the variables
System.out.println("Enter the Rate of interest : ");
r = sc.nextFloat(); //Initialize the variables
System.out.println("Enter the Time period : ");
t = sc.nextFloat(); //Initialize the variables
sc.close();
//Call a method to calculate the simple interest
float interest = simpleInterest(p,r,t);
System.out.println("Simple interest is : " + interest);
}
}
输入本金:4500
输入利率:12
输入时间段:3
单利为:1620.0
Java 程序：分离左侧的 0 和右侧的 1
在本教程中，我们将学习如何将数组左侧的 0 和右侧的 1 分开。但是在继续之前，如果您不熟悉数组的概念，那么请务必查看 Java 中的文章数组。
输入:0 0 1 0 1 0 1 1 0 1 1 1
输出:0 0 0 1 1 1 1 1 1 1
程序 1:左边分开 0，右边分开 1
在这个方法中，我们将看到如何使用排序技术将数组左侧的 0 和右侧的 1 分开。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 检查输入的元素是否为 0 和 1。
- 如果输入的元素不是 0 和 1，请用户再次输入。
- 如果输入的元素是 0 和 1，则使用 arrays.sort()对数组进行排序
- 这种排序将保持 0 在左侧，1 在右侧。
- 打印排序后的数组。
- 停下来。
下面的程序演示了如何使用排序技术将数组左侧的 0 和右侧的 1 分开。
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
static void printElements(int arr[],int n)
{
System.out.println("Resultant Array is ");
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println(" ");
}
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
int flag=1;
for(int t=0;t<n;t++)
{
if(arr[t]==0 || arr[t]==1)
{
Arrays.sort(arr); //Sort the array
flag++;
}
else
{
flag=0;
}
}
if(flag==0)
{
System.out.println("Elements other than 0 and 1 are entered");
System.out.println("Please Enter Valid Inputs ");
}
else{
printElements(arr,n);
}
}
}
输入元素总数 10
输入数组的元素 0 0 1 1 1 0 0 0
结果数组是
0 0 0 1 1 1 1
程序 2:左边分开 0，右边分开 1
在这个方法中，我们将看到如何使用分离技术来分离数组左侧的 0 和右侧的 1。
算法
- 开始
- 声明数组大小。
- 要求用户初始化数组大小。
- 声明数组。
- 要求用户初始化数组元素。
- 首先检查输入的元素是否为 0 和 1。
- 如果输入的元素不是 0 和 1，请用户再次输入。
- 如果输入的元素是 0 和 1，则声明一个变量来计算零的总数。
- 使用 for 循环迭代数组的每个元素。
- 在发现 0 的地方增加计数。
- 现在，用 0 填充循环直到计数。
- 用 1 填充数组的剩余元素。
- 停止
下面的程序演示了如何使用分离技术分离数组左侧的 0 和右侧的 1。
import java.util.*;
import java.util.Arrays;
//Driver Code
public class Main
{
static void printElements(int arr[],int n)
{
System.out.println("Resultant Array is ");
for(int i=0;i<n;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println(" ");
}
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int n; //Declare array size
System.out.println("Enter the total number of elements ");
n=sc.nextInt(); //Initialize array size
int arr[]=new int[n]; //Declare array
System.out.println("Enter the elements of the array ");
for(int i=0; i<n ;i++) //Initialize array
{
arr[i]=sc.nextInt();
}
int flag=1;
for(int t=0;t<n;t++)
{
if(arr[t]==0 || arr[t]==1)
{
// Counts the no of zeros in array
int count = 0;
// Iteration over each element of the array
for (int i = 0; i < n; i++)
{
if (arr[i] == 0)
count++; // Incrementing the count
}
// Loop to fill the array with 0 until count
for (int i = 0; i < count; i++)
arr[i] = 0;
// Loop to fill the remaining array space with 1
for (int i = count; i < n; i++)
arr[i] = 1;
flag++;
}
else
{
flag=0;
}
}
if(flag==0)
{
System.out.println("Elements other than 0 and 1 are entered");
System.out.println("Please Enter Valid Inputs ");
}
else
{
printElements(arr,n);
}
}
}
输入元素总数 10
输入数组的元素 0 0 1 1 0 1 1 0 0
结果数组是
0 0 0 1 1 1 1
基本程序
Java 程序：使用递归打印整数的二进制表示
在本教程中，我们将学习如何使用递归打印整数的二进制表示。递归函数是调用自身的函数。但是在进一步讨论之前，如果您不熟悉 java 中 if 语句的概念，那么一定要查看主题为 Java 中条件语句的文章。
输入:输入数字:7
输出:等效二进制数为 111
程序 1:使用递归打印整数的二进制表示
在这个程序中，我们将看到如何使用递归打印整数的二进制表示。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量来存储数字。
- 要求用户初始化数字。
- 把这个数除以 2。
- 当数除以 2 时，存储余数。
- 重复以上两个步骤，直到数字大于零。
- 以相反的顺序打印数字。
- 停下来。
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to convert an integer to binary
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
int n;
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number:");
n = sc.nextInt();
Main obj = new Main();
int m = obj.binary(n);
System.out.println("The binary equivalent is:"+m);
}
public static int binary(int n)
{
if (n == 1)
{
return 1;
}
return binary(n / 2) * 10 + n % 2;
}
}
输入数字:9
二进制等值为:1001
程序 2:使用递归打印整数的二进制表示
在这个程序中，我们将看到如何使用递归打印整数的二进制表示。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量来存储数字。
- 要求用户初始化数字。
- 声明一个静态方法，该方法采用一个整数参数作为参数并返回一个字符串。
- 使用 StringBuilder 类将结果相互追加，并使用 toString()方法将输出生成器对象转换为字符串。
- 将特定数字除以 2，并将余数存储在变量中。
- 存储数字除以 2 后的整数值。
- 再次调用该函数，并用余数追加其结果
- 满足基本条件(number == 0)后，它从方法返回 StringBuilder 对象。
- 打印结果。
- 停下来。
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to convert an integer to binary
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
int n;
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number:");
n = sc.nextInt();
Main obj = new Main();
String m = obj.BRec(n);
System.out.println("The binary equivalent is:"+m);
}
public static String BRec(int num)
{
StringBuilder sB = new StringBuilder();
if(num > 0)
{
//get the remainder of the number when divided with 2
int rem = num % 2;
//get the whole number after the division
num /= 2;
sB.append(BRec(num)).append("").append(String.valueOf(rem));
return sB.toString();
}
else
{
return sB.toString();
}
}
}
输入数字:9
二进制等值为:1001
Java 程序：不使用递归将二进制数转换为格雷码
在本教程中，我们将学习如何在不使用递归的情况下将数字的二进制数转换为其等效的格雷代码。格雷码是一种二进制数字系统，其中两个连续值仅相差一位。但是在继续之前，如果你不熟悉 java 中方法的基本概念，那么一定要查看主题为 java 中方法的文章。
输入:输入二进制数:1110
输出:等效格雷码为:1001
让我们看看例子，以便更好地理解。
程序 1:不使用递归将一个数的二进制码转换成它的等价格雷码
在这个例子中，我们将看到如何在不使用递归的情况下将数字的二进制数转换成它的等价格雷码。
算法:
- 开始
- 创建扫描仪类的实例。
- 声明一个变量来存储二进制数。
- 要求用户初始化变量。
- 声明一个用户定义的方法来将二进制数转换为格雷码。
- 遍历字符串的所有位。
- 对二进制字符串的前一位和当前位执行异或运算。
- 重复这个过程，直到字符串的所有位都被覆盖。
- 打印结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to Convert Binary Code Into
//Equivalent Gray Code Without Using Recursion
import java.util.*;
public class Main
{
public static void toGray(String str)
{
// a String varaible to store the obtained gray string.
String gray = new String();
gray += str.charAt(0);
for (int i = 1; i < str.length(); i++)
{
// perform XOR on the prevous bit and the
// current bit of the binary string
gray += (Integer.parseInt(String.valueOf(str.charAt(i - 1))) ^
Integer.parseInt(String.valueOf(str.charAt(i))));
}
System.out.println("The equivalent gray code is : " + gray);
}
// Driver Program
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter the Binary number:");
String str = sc.nextLine();
toGray(str);
}
}
输入二进制数:111011001
等效的格雷码为:100110101
程序 2:不使用递归将一个数的二进制码转换成它的等价格雷码
在这个例子中，我们将看到如何在不使用递归的情况下将数字的二进制数转换成它的等价格雷码。
算法:
- 开始
- 创建扫描仪类的实例。
- 声明一个变量来存储二进制数。
- 要求用户初始化变量。
- 声明一个用户定义的方法来将二进制数转换为格雷码。
- 首先，遍历字符串的所有字符。
- 声明另一个单独的用户定义函数，该函数将返回两个数字的异或。
- 重复这些步骤，直到找到字符串所有位的 xor 值。
- 显示输出。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to Convert Binary Code Into
//Equivalent Gray Code Without Using Recursion
import java.util.*;
public class Main
{
public static int xOR(char a, char b)
{
// return 1 if both bits are not same
if (a != b)
return 1;
// else return 0
return 0;
}
// converts the given binary string into its equivalent gray code
public static void toGray(String str)
{
String gray = new String();
gray += str.charAt(0);
// for all the other bits, traverse through the
// binary string
for (int i = 1; i < str.length(); i++)
{
// calling xOR() method on the prevous bit and
// the current bit of the binary string
gray += xOR(str.charAt(i - 1), str.charAt(i));
}
System.out.println("The equivalent gray code is : " + gray);
}
// Driver Program
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter the Binary number:");
String str = sc.nextLine();
toGray(str);
}
}
输入二进制数:100011001
等效的格雷码为:110010101
Java 程序：使用递归求数字和
在本教程中，我们将学习如何使用递归找到一个数字的所有数字的总和。递归函数是重复调用自身的函数。在这里，我们将首先要求用户初始化数字，然后通过递归调用函数来找到所有的数字并计算它们的总和。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入数字:564
输出:所有数字之和为:15
让我们看看例子，了解如何用递归求数字的和。
程序 1:一个数字的数字总和
在下面的例子中，我们将看到如何使用递归来求一个数的位数之和。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量来存储数字。
- 要求用户初始化变量。
- 声明一个用户定义的函数，使用递归计算数字的位数总和。
- 递归调用函数来计算数字的总和。
- 显示数字的总和。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to find the sum of digits using recursion
import java.util.*;
public class Main
{
public static int sum_of_digit(int num)
{
if (num == 0)
return 0;
return (num % 10 + sum_of_digit(num / 10));
}
// Driver Program
public static void main(String args[])
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number: ");
int num=sc.nextInt();
int res=sum_of_digit(num);
System.out.println("The sum of digits is: "+res);
}
}
输入数字 854
该数字的位数总和为 17
程序 2:一个数字的数字总和
在下面的例子中，我们将看到如何使用递归来求一个数的位数之和。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量来存储数字。
- 要求用户初始化变量。
- 声明一个用户定义的函数，使用递归计算数字的位数总和。
- 递归调用函数来计算数字的总和。
- 返回计算出的总和。
- 打印结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to find the sum of digits using recursion
import java.util.*;
public class Main
{
int sum=0;
int sumOfDigits(long num)
{
if(num!=0)
{
sum+=num%10;
num/=10;
sumOfDigits(num);
}
return sum;
}
//Driver code
public static void main(String arg[])
{
long num,res;
Main main=new Main();
//Take input from the user
//Create an instance of the Scanner class
Scanner sc=new Scanner(System.in);
System.out.println("Enter a number ");
num=sc.nextLong();
System.out.println("The sum of digits of the number is "+main.sumOfDigits(num));
}
}
输入一个数字 4567854
这个数字的位数总和是 39
Java 程序：使用方法重载求正方形、矩形和圆形面积
在本教程中，我们将学习如何使用方法重载来查找正方形、矩形和圆形的面积。矩形的面积是它的长度和宽度的乘积。圆的面积是圆半径的平方和圆周率的乘积。正方形的面积是它的边的平方。如果一个类有多个同名但参数不同的方法，称为方法重载。但是在继续之前，如果你不熟悉 java 中方法重载的概念，那么一定要检查一下 Java 中的方法重载。
输入:区域(3)
面积(3，2)
区域(3.2)
输出:
这个广场的面积是 9 平方。单位。
这个长方形的面积是 6 平方。单位。
这个圆的面积是 32.15 平方。单位。
让我们看看下面的例子，以便更好地理解。
Java 程序：程序 1:使用方法重载寻找正方形、矩形和圆形区域
在这个程序中，我们将看到如何使用方法重载来找到正方形、矩形和圆形的面积。
算法:
- 开始
- 为矩形、正方形和圆形声明三个不同的类。
- 声明两个同名但具有不同数量参数或不同数据类型的方法。
- 使用对象调用这些方法。
- 根据参数数量或数据类型调用相应的方法。
- 显示结果。
- 停下来。
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to Find the Area of Square, Rectangle and Circle using Method Overloading
public class Main
{
//Driver Code
public static void main(String[] args)
{
Rectangle obj = new Rectangle();
// Calling function
obj.Area(30, 20);
obj.Area(12.5, 4.5);
Circle obj1 = new Circle();
// Calling function
obj1.Area(3);
obj1.Area(5.5);
Square obj2 = new Square();
// Calling function
obj2.Area(20);
obj2.Area(5.2);
}
}
class Square
{
// Overloaded function to
// calculate the area of the square
// It takes one double parameter
void Area(double side)
{
System.out.println("Area of the Square: "+ side * side);
}
// Overloaded function to
// calculate the area of the square
// It takes one float parameter
void Area(float side)
{
System.out.println("Area of the Square: "+ side * side);
}
}
class Circle
{
static final double PI = Math.PI;
// Overloaded function to
// calculate the area of the circle.
// It takes one double parameter
void Area(double r)
{
double A = PI * r * r;
System.out.println("The area of the circle is :" + A);
}
// Overloaded function to
// calculate the area of the circle.
// It takes one float parameter
void Area(float r)
{
double A = PI * r * r;
System.out.println("The area of the circle is :" + A);
}
}
class Rectangle
{
// Overloaded function to
// calculate the area of the rectangle
// It takes two double parameters
void Area(double l, double b)
{
System.out.println("Area of the rectangle: " + l * b);
}
// Overloaded function to
// calculate the area of the rectangle.
// It takes two float parameters
void Area(int l, int b)
{
System.out.println("Area of the rectangle: " + l * b);
}
}
矩形面积:600
矩形面积:56.25
圆面积:28.274333882308138
圆面积:95.03317777109123
广场面积:400.0
广场面积:27.040000000000003
程序 2: Java 程序使用方法重载寻找正方形、矩形和圆形的面积
在这个程序中，我们将看到如何使用方法重载来找到正方形、矩形和圆形的面积。
算法:
- 开始
- 用不同数量的参数或不同的数据类型声明三个同名的方法。
- 使用对象调用这些方法。
- 根据参数数量或数据类型调用相应的方法。
- 显示结果。
- 停下来。
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to Find the area of Square, Rectangle and Circle using Method Overloading
public class Main
{
//Driver Code
public static void main(String[] args)
{
CalculateArea ob = new CalculateArea();
ob.area(4);
ob.area(10,12);
ob.area(5.5);
}
}
class CalculateArea
{
void area(float x)
{
System.out.println("The area of the square is "+Math.pow(x, 2)+" sq units");
}
void area(float x, float y)
{
System.out.println("The area of the rectangle is "+x*y+" sq units");
}
void area(double x)
{
double z = 3.14 * x * x;
System.out.println("The area of the circle is "+z+" sq units");
}
}
正方形的面积是 16.0 平方米
长方形的面积是 120.0 平方米
圆形的面积是 94.985 平方米
Java 程序：计算梯形面积
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-area-of-a-trapezium
在本教程中，我们将学习如何在 java 中计算梯形的面积。梯形是 2D 形状，属于有一对平行边的四边形的范畴。梯形面积是二维平面中由梯形覆盖的区域。但是在继续之前，如果你不熟悉数据类型的概念，那么一定要查看关于 Java 中数据类型的文章。
输入:输入梯形平行边的长度:5
输入梯形平行边的长度:3
输入梯形的高度:4
输出:梯形的面积:16
下面是同样的图示。
上述问题出现了两种情况:
情况 1:当给定平行边和高度时
案例二:当所有的边都给了。
让我们分别看看这些案例。
Java 程序：程序 1:寻找梯形面积
在这个程序中，我们将学习如何使用底部和高度公式来寻找梯形的面积。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储梯形边的值。
- 要求用户初始化变量。
- 声明另一个变量来存储梯形的高度。
- 使用底部和高度公式计算面积。
- 显示结果。
- 停下来。
下面的程序演示了如何找到梯形的面积。
//Java Program to Calculate the Area of a Trapezium
import java.util.Scanner;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the length of the parallel sides of the trapezium: ");
double side1=sc.nextDouble();
System.out.println("Enter the length of the parallel sides of the trapezium: ");
double side2=sc.nextDouble();
System.out.println("Enter the height of the trapezium: ");
double height = sc.nextDouble();
//Calculate the area
double area=((side1+side2)*height)/2;
if (side1 <= 0 || side2<=0)
System.out.println("Length should be positve");
else
System.out.println("Area of trapezium = "+ area);
}
}
输入斜方肌平行边长度:6
输入斜方肌平行边长度:8
输入斜方肌高度:6
斜方肌面积= 42.0
Java 程序：程序 2:寻找梯形面积
在这个程序中，我们将学习当给定梯形的所有边时，如何找到梯形的面积。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储梯形边的值。
- 要求用户初始化变量。
- 声明另一个变量来存储梯形的半周长。
- 从梯形的半周长减去边。
- 计算上述结果的平方根。
- 现在，用公式计算梯形的面积。
- 显示结果。
- 停下来。
下面的程序演示了如何找到梯形的面积。
//Java Program to Calculate the Area of a Trapezium
import java.util.Scanner;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the length of the longer side of the trapezium: ");
double a=sc.nextDouble();
System.out.println("Enter the length of the shorter side of the trapezium: ");
double b=sc.nextDouble();
System.out.println("Enter the length of the non-parallel side of the trapezium: ");
double c = sc.nextDouble();
System.out.println("Enter the length of the non-parallel side of the trapezium: ");
double d = sc.nextDouble();
double s =(a+b+c+d)/2;
double num=(s-a)*(s-b)*(s-b-c)*(s-b-d);
double res=Math.sqrt(num);
//Calculate the area
double Area =(a+b)/(a-b)*res;
if (a <= 0 || b<=0 || c<=0 || d<=0)
System.out.println("Length should be positve");
else
System.out.println("Area of trapezium = "+ Area);
}
}
输入斜方肌长边长度:14
输入斜方肌短边长度:6
输入斜方肌非平行边长度:5
输入斜方肌非平行边长度:5
斜方肌面积= 30.0
Java 程序：计算圆的周长
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-perimeter-of-a-circle
在本教程中，我们将学习如何用 java 计算圆、矩形和三角形的周长。形状的周长被定义为包围/包围/勾勒形状的路径。圆是由平面上离给定点(中心)给定距离的所有点组成的形状。矩形被定义为具有四个直角的四边形。三角形被定义为具有三条边和三个顶点的多边形。但是在继续之前，如果你不熟悉数据类型的概念，那么一定要查看关于 Java 中数据类型的文章。
输入:输入圆的半径:5
输入矩形的长度:4
输入矩形的宽度:5
输入三角形的边数:3
输入三角形的边数:4
输入三角形的边数:5
输出:
圆的面积:31.4
矩形的面积:18.0
三角形的面积:12.0
上述情况有两种情况:
情况 1:当给定边和半径时
情况 2:当给定面积时
让我们分别看看这些案例。
程序 1:寻找圆、矩形和三角形的周长
在这个程序中，我们将看到如何在给定边和半径的情况下用 java 计算圆、矩形和三角形的周长。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储矩形、三角形和圆形的边和半径值。
- 要求用户初始化变量。
- 声明另一个变量来存储周长。
- 创建 Main 类的对象。
- 创建三种用户定义的方法来计算矩形、三角形和圆形的周长。
- 使用公式计算它们的周长。
- 显示结果。
- 停止
下面的程序演示了如何用 java 计算圆、矩形和三角形的周长。
//Java Program to Calculate the Perimeter of a Circle, Rectangle, and Triangle
import java.util.Scanner;
public class Main
{
double pi = 3.14,perimeter;
Scanner s = new Scanner(System.in);
void circle()
{
System.out.println("Enter the radius of circle: ");
int radius = s.nextInt();
perimeter = 2 * pi * radius;
System.out.println("The perimeter of the circle: "+perimeter);
}
void rectangle()
{
System.out.println("Enter length of rectangle: ");
int length = s.nextInt();
System.out.println("Enter breadth of rectangle: ");
int breadth = s.nextInt();
perimeter = 2 * (length + breadth);
System.out.println("The perimeter of the rectangle: "+perimeter);
}
void triangle()
{
System.out.println("Enter the length of the first side of triangle: ");
int side1 = s.nextInt();
System.out.println("Enter the length of the second side of triangle: ");
int side2 = s.nextInt();
System.out.println("Enter the length of the third side of triangle: ");
int side3 = s.nextInt();
perimeter = side1 + side2 + side3;
System.out.println("The perimeter of the triangle: "+perimeter);
}
public static void main(String []args)
{
Main obj=new Main();
obj.circle();
obj.rectangle();
obj.triangle();
}
}
输入圆的半径:5
圆的周长:31.400000000000002】输入矩形的长度:2
输入矩形的宽度:3
矩形的周长:10.0
输入三角形第一条边的长度:6
输入三角形第二条边的长度:7
输入三角形第三条边的长度:8
三角形的周长:21.0
程序 2:寻找圆、矩形和三角形的周长
在这个程序中，我们将看到当面积给定时，如何在 java 中计算圆、矩形和三角形的周长。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储矩形、三角形和圆形区域的值。
- 要求用户初始化变量。
- 声明其他变量来存储矩形和三角形的其他参数。
- 创建 Main 类的对象。
- 创建三种用户定义的方法来计算矩形、三角形和圆形的周长。
- 使用公式计算它们的周长。
- 显示结果。
- 停止
下面的程序演示了如何用 java 计算圆、矩形和三角形的周长。
//Java Program to Calculate the Perimeter of a Circle, Rectangle, and Triangle
import java.util.Scanner;
public class Main
{
double pi = 3.14,perimeter;
Scanner s = new Scanner(System.in);
void circle()
{
System.out.println("Enter the area of the circle: ");
double area = s.nextDouble();
perimeter = 2*(Math.sqrt(pi*area));
System.out.println("The perimeter of the circle: "+perimeter);
}
void rectangle()
{
System.out.println("Enter the length of the rectangle: ");
double length = s.nextDouble();
System.out.println("Enter the area of the rectangle: ");
double area = s.nextDouble();
double res=2*(area/length);
perimeter =res+(2*length);
System.out.println("The perimeter of the rectangle: "+perimeter);
}
void triangle()
{
System.out.println("Enter the length of the first side of triangle: ");
double side1 = s.nextDouble();
System.out.println("Enter the length of the second side of triangle: ");
double side2 = s.nextDouble();
System.out.println("Enter the length of the height of the triangle: ");
double h = s.nextDouble();
System.out.println("Enter the area of the triangle: ");
double area = s.nextDouble();
if(h<=side1 && h<=side2) {
double res=2*(area/h);
perimeter = side1 + side2 + res;
System.out.println("The perimeter of the triangle: "+perimeter);
}
else
{
System.out.println("Enter the correct value of h");
}
}
public static void main(String []args)
{
Main obj=new Main();
obj.circle();
obj.rectangle();
obj.triangle();
}
}
输入圆的面积:50
圆的周长:25.059928172283335
输入矩形的长度:2
输入矩形的面积:5
矩形的周长:9.0
输入三角形第一条边的长度:6
输入三角形第二条边的长度:7
输入三角形高度的长度:5
输入三角形的面积
Java 程序：使用递归求两个数乘积
在本教程中，我们将学习如何使用递归函数找到两个数字的乘积。递归函数是调用自身的函数。但是在继续之前，如果你不熟悉 java 中嵌套 if 语句的概念，那么一定要查看主题为【Java 中的 T0】条件语句的文章。
输入:输入数字:7
输入数字:4
输出:两个数的乘积是 28。
上述情况有两种情况:
情况 1:当值被预定义时
情况 2:当值由用户定义时
让我们看一下如何用递归函数求两个数的乘积的例子。
程序 1:用递归求两个数的乘积
在这个程序中，我们将看到如何使用带有预定义值的递归来找到两个数字的乘积。
算法:
- 开始
- 声明两个变量。
- 要求用户初始化这些变量。
- 调用递归函数求这两个数的乘积。
- 如果第一个数字小于第二个数字，则交换这些值。
- 递归求第二个数乘以第一个数的和。
- 如果其中任何一个变为零，则返回零。
- 显示结果。
- 停下来。
下面的例子演示了如何用递归求两个数的乘积。
//Java Program to Find the Product of Two Numbers Using Recursion
import java.io.*;
import java.util.*;
public class Main
{
// recursive function to calculate the product of two numbers
static int findProduct(int num1, int num2)
{
// if x is less than y then swap the numbers
if (num1 < num2)
return findProduct(num2, num1);
// iteratively calculate y times sum of x
else if (num2 != 0)
return (num1 + findProduct(num1, num2 - 1));
// if any of the two numbers is zero return zero
else
return 0;
}
// Driver Code
public static void main (String[] args)
{
int num1 = 7;
System.out.println("The first entered number is: "+num1);
int num2 = 8;
System.out.println("The second entered number is: "+num2);
System.out.print("The product of the two numbers is ");
System.out.println(findProduct(num1, num2));
}
}
第一个输入的数字是:7
第二个输入的数字是:8
两个数字的乘积是 56
程序 2:用递归求两个数的乘积
在这个程序中，我们将看到如何使用带有用户定义值的递归来找到两个数字的乘积。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明两个变量。
- 要求用户初始化这些变量。
- 调用递归函数求这两个数的乘积。
- 如果第一个数字小于第二个数字，则交换这些值。
- 递归求第二个数乘以第一个数的和。
- 如果两个数都小于 0，则返回它们绝对值的乘积。
- 如果其中任何一个变为零，则返回零。
- 显示结果。
- 停下来。
下面的例子演示了如何用递归求两个数的乘积。
//Java Program to Find the Product of Two Numbers Using Recursion
import java.util.*;
public class Main
{
// recursive function to calculate the product of two numbers
static int findProduct(int num1, int num2)
{
if (num1 > 0 && num2 < 0)
{
return findProduct(num2, num1);
}
// case 2 : both num1 and num2 are less than 0
// return the product of their absolute values
else if (num1 < 0 && num2 < 0)
{
return findProduct((-1 * num1), (-1 * num2));
}
// if num1 > num2 , swap num1 and num2
if (num1 > num2)
{
return findProduct(num2, num1);
}
else if (num2 != 0)
{
return num1 + findProduct(num1, num2 - 1);
}
// num1=0 then return 0
else
{
return 0;
}
}
// Driver Code
public static void main (String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the first number");
int num1 = sc.nextInt();
System.out.println("Enter the second number");
int num2 = sc.nextInt();
System.out.print("The product of the two numbers is ");
System.out.println(findProduct(num1, num2));
}
}
输入第一个数字:4
输入第二个数字:-5
两个数字的乘积是-20
Java 程序：计算长方体表面积和体积
在本教程中，我们将学习如何在 java 中找到长方体的表面积和体积。长方体是由六个面、八个顶点和十二条边组成的三维图形。长方体的表面积等于它的六个矩形面的面积之和。长方体的体积等于一个面的面积和高度的乘积。但是在继续之前，如果您不熟悉 java 中数据类型的概念，那么一定要查看主题为Java 中数据类型的文章
输入:输入长方体的长度:5
输入长方体的宽度:7
输入长方体的高度:2
输出:长方体的表面积为:118
长方体的体积是:70
程序 1:求长方体的表面积和体积
在这个例子中，我们将看到如何在 java 中计算长方体的表面积和体积。
算法:
- 开始
- 创建扫描仪类的实例
- 声明变量来存储长方体的长度、宽度和高度。
- 要求用户初始化这些变量。
- 声明变量来存储长方体的表面积和体积。
- 使用公式计算值。
- 显示表面积和体积。
- 停下来。
下面的例子演示了如何计算长方体的表面积和体积。
//Java Program to Find the Surface Area and Volume of Cuboid
import java.util.*;
public class Main
{
// Driver Code
public static void main (String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the length of the cuboid: ");
int length=sc.nextInt();
System.out.println("Enter the breadth of the cuboid: ");
int breadth=sc.nextInt();
System.out.println("Enter the height of the cuboid: ");
int height=sc.nextInt();
int surface_area=2*((length*breadth)+(breadth*height)+(height*length));
System.out.println("The surface area of the cuboid is: "+surface_area);
int volume=length*breadth*height;
System.out.println("The volume of the cuboid is: "+volume);
}
}
输入长方体长度:4
输入长方体宽度:9
输入长方体高度:6
长方体表面积:228
长方体体积:216
程序二:求长方体的表面积和体积
在这个例子中，我们将看到如何在 java 中计算长方体的表面积和体积。
算法:
- 开始
- 创建扫描仪类的实例
- 声明变量来存储长方体的长度、宽度和高度。
- 要求用户初始化这些变量。
- 调用两个用户定义的方法来计算长方体的表面积和体积。
- 将输入的值作为参数传递。
- 声明变量来存储长方体的表面积和体积。
- 使用公式计算值。
- 返回计算值。
- 显示长方体的计算表面积和体积。
- 停下来。
下面的例子演示了如何计算长方体的表面积和体积。
//Java Program to Find the Surface Area and Volume of Cuboid
import java.util.*;
public class Main
{
// Driver Code
public static void main (String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the length of the cuboid: ");
int length=sc.nextInt();
System.out.println("Enter the breadth of the cuboid: ");
int breadth=sc.nextInt();
System.out.println("Enter the height of the cuboid: ");
int height=sc.nextInt();
//Calculate the surface area
int area= findSurfaceArea(length,breadth,height);
System.out.println("The surface area of the cuboid is: "+area);
//Calculate the volume
int vol=findVolume(length,breadth,height);
System.out.println("The volume of the cuboid is: "+vol);
}
//User-defined methood for surface area of cuboid
public static int findSurfaceArea(int length,int breadth, int height)
{
int surface_area=2*((length*breadth)+(breadth*height)+(height*length));
return surface_area;
}
//User-defined methood for volume of cuboid
public static int findVolume(int length,int breadth, int height)
{
int volume=length*breadth*height;
return volume;
}
}
输入长方体长度:9
输入长方体宽度:3
输入长方体高度:7
长方体表面积:222
长方体体积:189
Java 程序：计算球体表面积和体积
在本教程中，我们将学习如何在 java 中找到球体的表面积和体积。完美对称的三维圆形物体是球体。从中心到边界的连线叫做球的半径。球体的表面积被定义为其外表面在三维空间中所覆盖的区域。球体的体积被定义为它的容量。但是在继续之前，如果你不熟悉 java 中数据类型的概念，那么一定要查看主题为Java 中数据类型的文章。
下图是球体的图示。
输入:输入球体半径:5
输出:球体表面积:314
球体的体积是 523.33
让我们看看例子，知道如何找到球体的表面积和体积。
程序 1:求球体的表面积和体积
在这个例子中，我们将学习如何用 java 计算球体的表面积和体积。
算法:
- 开始
- 创建扫描仪类的实例
- 声明一个变量来存储球体的半径。
- 要求用户初始化变量。
- 声明变量来存储球体的表面积和体积。
- 使用公式计算值。
- 显示计算出的球体表面积和体积
- 停下来。
下面的例子演示了如何找到一个球体的表面积和体积。
//Java Program to Find the Surface Area and Volume of Sphere
import java.util.*;
public class Main
{
// Driver Code
public static void main (String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the radius of the sphere: ");
double radius=sc.nextDouble();
double surface_area = 4 * 3.14 * (radius * radius);
double volume = ((double)4 / 3) * 3.14 * (radius * radius * radius);
System.out.println("The surface area of the sphere = "+surface_area);
System.out.println("The volume of sphere = "+volume);
}
}
输入球体的半径:10
球体的表面积= 1256.0
球体的体积= 4186。56860 . 66666666666
程序 2:求球体的表面积和体积
在这个例子中，我们将学习如何用 java 计算球体的表面积和体积。
算法:
- 开始
- 创建扫描仪类的实例
- 声明变量来存储球体的半径。
- 要求用户初始化这些变量。
- 调用两个用户定义的方法来计算球体的表面积和体积。
- 将输入的值作为参数传递。
- 声明变量来存储球体的表面积和体积。
- 使用公式计算值。
- 返回计算值。
- 显示计算出的球体表面积和体积。
- 停下来。
下面的例子演示了如何找到球体的表面积和体积
//Java Program to Find the Surface Area and Volume of Sphere
import java.util.*;
public class Main
{
//Calculate the Volume of Sphere
public static double VolumeOfSphere (double radius)
{
double Volume = (4.0 / 3) * Math.PI * radius * radius * radius;
return Volume;
}
//Calculate the Surface Area of Sphere
public static double SurfaceAreaOfSphere (double radius)
{
double surfacearea = 4 * Math.PI * radius * radius;
return surfacearea;
}
// Driver Code
public static void main (String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the radius of the sphere: ");
double radius=sc.nextDouble();
double surface_area = SurfaceAreaOfSphere(radius);
double volume = VolumeOfSphere(radius);
System.out.println("The surface area of the sphere = "+surface_area);
System.out.println("The volume of sphere = "+volume);
}
}
输入球体的半径:4
球体的表面积= 201.06192982974676
球体的体积= 268 . 58688 . 58686868666
Java 程序：以三角形形式打印乘法表
在本教程中，我们将学习如何以三角形形式打印乘法表。在这种形式中，表格是按行和列显示的，在每一行中，只有相同列号的条目被填充。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:7
输出:三角形表格:
One million two hundred and thirty-four thousand five hundred and sixty-seven
one
2 4
3 6 9
4 8 12 16
5 10 15 20 25
6 12 18 24 30 36
7 14 21 28 35 42 49
进场:
- 首先，输入行数。
- for(I = 0；I
- for(I = 0；I
- 的嵌套循环(j = 0；j < = I；j++)，用于打印当前条目。
让我们看一下例子来理解上述方法的实现。
程序 1:以三角形形式打印乘法表
在这个程序中，我们将看到如何以三角形的形式打印乘法表。
算法:
- 开始
- 创建一个 BufferedReader 类的实例。
- 声明一个变量来存储行数。
- 要求用户初始化变量。
- 使用 for 循环打印表格的第一行。
- 现在用两个 for 循环来打印乘法表。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to Print the Multiplication Table in Triangular Form
import java.util.*;
public class Main
{
public static void main(String args[])
{
int rows, i, j;
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number of rows: ");
rows = sc.nextInt();
// Loop to print multiplication
// table in triangular form
for (i = 1; i <= rows; i++)
{
System.out.print(i+" ");
}
System.out.println();
for (i = 1; i <= rows; i++)
{
for (j = 1; j <= i; j++)
{
System.out.print(i * j + " ");
}
System.out.println();
}
}
}
输入行数:6
1 2 3 4 5 6
1
2 4
3 6 9
4 8 12 16
5 10 15 20 25
6 12 18 24 30 36
程序 2:以三角形形式打印乘法表
在这个程序中，我们将看到如何使用 try-catch 块以三角形形式打印乘法表。
算法:
- 开始
- 创建一个 BufferedReader 类的实例。
- 声明一个变量来存储行数。
- 要求用户初始化变量。
- 使用 try-catch 块来确保用户提供了正确的输入。
- 使用 for 循环打印表格的第一行。
- 现在用两个 for 循环来打印乘法表。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to Print the Multiplication Table in Triangular Form
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main
{
public static void main(String[] args)
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int row;
System.out.println("Enter the number of rows: ");
try
{
row = Integer.parseInt(br.readLine());
}
catch(Exception e)
{
System.out.println("An error occurred");
return;
}
int i,j;
System.out.println("The table in triangular form is");
for(i=1; i<=row; i++)
{
System.out.printf("%2d ",i);
}
System.out.println();
for(i=1; i<=row; i++)
{
for(j=1; j<=i; j++)
{
System.out.printf("%2d ",i*j);
}
System.out.println();
}
}
}
输入行数:8
三角形表格为
1 2 3 4 5 6 7 8
1
2 4
3 6 9
4 8 12 16
5 10 15 20 25
6 12 18 24 30 36
7 14 21 28 35 42 49
8 16 24 32 40 48 56 64
Java 程序：使用递归将一个数的二进制码转换成等价格雷码
在本教程中，我们将学习如何使用递归将数字的二进制代码转换为其等效的格雷代码。格雷码是一种二进制数字系统，其中两个连续值仅相差一位。递归函数是调用自身的函数。但是在继续之前，如果你不熟悉 java 中方法的基本概念，那么一定要查看主题为 java 中方法的文章。
输入:输入二进制数:1110
输出:等效格雷码为:1001
程序 1:用递归把一个数的二进制码转换成它的等价格雷码
在这个例子中，我们将看到当数字在整数限制内时，如何使用递归将数字的二进制代码转换成它的等价格雷码。
算法:
- 开始
- 创建扫描仪类的实例。
- 声明一个变量来存储二进制数。
- 要求用户初始化变量。
- 声明一个用户定义的方法来将二进制代码转换为格雷码。
- 如果数字为 0，则返回 0。
- 提取最后一个数字和第二个数字。
- 否则，如果最后两位是相反的，那么 gray = 1+(10 * binary gray(number/10))。
- 否则，如果最后两位相同，那么 gray = 10 * binaryToGray(数字/10)
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program to Convert Binary Code Into
//Equivalent Gray Code Using Recursion
import java.util.*;
public class Main
{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter the binary number: ");
int bNumber = sc.nextInt();
int res = bToGray(bNumber);
System.out.println("Gray Code is " + res);
}
public static int bToGray(int num)
{
if (num == 0)
{
return 0;
}
// Extracting the last digit
int x1 = num % 10;
// Extracting the second last digit
int x2 = (num / 10) % 10;
// Else If last two digits
// are opposite bits to each other
if ((x1 & ~x2) == 1 || (~x1 & x2) == 1) {
return (1 + 10 * bToGray(num / 10));
}
// Else If the last
// two bits are same
return (10 * bToGray(num / 10));
}
}
输入二进制数:1101
格雷码为 1011
程序 2:用递归把一个数的二进制码转换成它的等价格雷码
在这个例子中，我们将看到当输入大的二进制数时，如何使用递归将数字的二进制码转换成它的等价格雷码。
算法:
- 开始
- 创建扫描仪类的实例。
- 声明一个变量以字符串格式存储二进制数。
- 要求用户初始化变量。
- 声明一个用户定义的函数来求两个数的异或。
- 递归调用函数，找到输入数字的格雷码。
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program to Convert Binary Code Into
//Equivalent Gray Code Using Recursion
import java.util.*;
public class Main
{
public static char xor(char a, char b)
{
if (a == b)
return '0';
else
return '1';
}
// Recursive function Gray code conversion
public static char[] ans(char[] ch, String str, int i)
{
if (i == str.length())
return ch;
ch[i] = xor(str.charAt(i), str.charAt(i - 1));
i++;
return ans(ch, str, i);
}
// Driver Program
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter Binary number:");
String str = sc.nextLine();
char[] ch = new char[str.length()];
ch[0] = str.charAt(0);
// Recursive function call
ans(ch, str, 1);
// Print Gray Code
System.out.print("Gray Code is ");
for (char i : ch)
System.out.print(i + "");
}
}
输入二进制数:1110011
格雷码为 1001010
Java 程序：使用递归求N个数总和
原文：https://www.studytonight.com/java-programs/java-program-to-find-sum-of-n-numbers-using-recursion
在本教程中，我们将看到如何使用递归找到 N 个数字的和。递归函数是调用自身的函数。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入数字:6 7 4 5 3
输出:所有输入的数字之和为:25
程序 1:用递归求 N 个数的和
在这个程序中，我们将看到如何使用递归计算 N 个数的和。这里，我们将考虑函数中的长度变量作为变化参数。
算法:
-
开始
-
创建扫描仪类的实例。
-
声明一个变量来存储数组的长度。
-
要求用户初始化数组大小。
-
声明一个变量来存储数组元素。
-
要求用户初始化数组元素。
-
调用递归函数计算总和。
-
将长度变量视为函数中的变化参数。
-
递归调用函数来计算总和。
-
显示计算出的总和。
-
停下来。
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to Find Sum of N Numbers Using Recursion
import java.util.*;
public class Main
{
// recursive function
public static int calculate_sum(int arr[], int length)
{
// base condition - when reached -1 index return 0
if (length == -1)
{
return 0;
}
// Call the function recursively to calculate the sum
return arr[length] + calculate_sum(arr,length - 1);
}
//Driver Code
public static void main(String[] args)
{
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the array size: ");
int n=sc.nextInt();
int total_sum = 0;
//Array Creation and Initialization
int arr[] = new int[n];
System.out.println("Enter the array elements: ");
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt();
}
// call function to calculate sum
total_sum = calculate_sum(arr, n-1);
System.out.println("The total of N numbers is : "+ total_sum);
}
}
输入数组大小:5
输入数组元素:4 7 6 5 3
N 个数的总和为:25
程序 2:用递归求 N 个数的和
在这个程序中，我们将看到如何使用递归计算 N 个数的和。在这里，我们将从向前的方向开始递归，并在结束/最后的位置到达和命中基础条件。
算法:
-
开始
-
创建扫描仪类的实例。
-
声明一个变量来存储数组的长度。
-
要求用户初始化数组大小。
-
声明一个变量来存储数组元素。
-
要求用户初始化数组元素。
-
调用递归函数计算总和。
-
从正向开始递归。
-
递归调用函数来计算总和。
-
显示计算出的总和。
-
停下来。
让我们看看下面的例子，以更好地理解上述算法。
//Java Program to Find Sum of N Numbers Using Recursion
import java.util.*;
public class Main
{
// recursive function
public static int calculate_sum(int arr[], int i, int length)
{
// base condition - when reached end of the array
// return 0
if (i == length) {
return 0;
}
// recursive condition - current element + sum of
// (n-1) elements
return arr[i]
+ calculate_sum(arr, i + 1,length);
}
//Driver Code
public static void main(String[] args)
{
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the array size: ");
int n=sc.nextInt();
int total_sum = 0;
//Array Creation and Initialization
int arr[] = new int[n];
System.out.println("Enter the array elements: ");
for(int i=0;i<n;i++)
{
arr[i]=sc.nextInt();
}
// call function to calculate sum
total_sum = calculate_sum(arr,0,n);
System.out.println("The total of N numbers is : "+ total_sum);
}
}
输入数组大小:5
输入数组元素:2 6 4 7 8
N 个数的总和为:27
Java 程序：计算菱形面积
原文：https://www.studytonight.com/java-programs/java-program-to-find-the-area-of-a-rhombus
在本教程中，我们将学习如何在 java 中计算菱形的面积。菱形是四边长度都相同的四边形。菱形的面积可以定义为二维空间中菱形所包围的空间量。但是在继续之前，如果你不熟悉数据类型的概念，那么一定要查看关于 Java 中数据类型的文章。
输入:输入第一条对角线:6
输入第二个对角线:4
输出:菱形面积:24
下面是同样的图示。
Java 程序：程序 1:寻找菱形面积
在这个程序中，我们将学习如何使用底部和高度公式找到菱形的面积。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储菱形的底和高的值。
- 要求用户初始化变量。
- 声明另一个变量来存储菱形的面积。
- 使用底部和高度公式计算面积。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to Calculate the Area of a Rhombus
import java.util.Scanner;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the base of the rhombus: ");
double base=sc.nextDouble();
System.out.println("Enter the height of the rhombus: ");
double height=sc.nextDouble();
if (base <= 0 || height <= 0)
System.out.println("Length should be positve");
else
System.out.println("Area of rhombus = "+ (base * height));
}
}
输入菱形底部:3
输入菱形高度:4
菱形面积= 12.0
Java 程序：程序 2:寻找菱形面积
在这个节目中，我们将学习如何使用对角线来寻找菱形的面积。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储菱形对角线的值。
- 要求用户初始化这些变量。
- 声明另一个变量来存储菱形任意两条对角线之间的角度
- 要求用户初始化变量。
- 将其转换为弧度。
- 计算角度的正弦值。
- 用对角线公式计算菱形的面积，
- 打印菱形的面积值。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to Calculate the Area of a Rhombus
import java.util.Scanner;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the first diagonal of the rhombus: ");
double d1=sc.nextDouble();
System.out.println("Enter the second diagonal of the rhombus: ");
double d2=sc.nextDouble();
if (d1 <= 0 || d2 <= 0)
System.out.println("Length should be positve");
else
System.out.println("Area of rhombus = "+ (d1 * d2) / 2);
}
}
进入菱形第一对角线:30
进入菱形第二对角线:40
菱形面积= 600.0
Java 程序：程序 3:寻找菱形面积
在这个节目中，我们将学习如何用三角学找到菱形的面积。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量来存储菱形边的值。
- 要求用户初始化变量。
- 声明另一个变量来存储菱形两边之间的角度。
- 要求用户初始化角度。
- 将其转换为弧度。
- 计算角度的正弦值。
- 用三角公式计算菱形的面积。
- 打印菱形的面积值。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program to Calculate the Area of a Rhombus
import java.util.Scanner;
public class Main
{
public static void main(String []args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the length of any side of the rhombus: ");
double side=sc.nextDouble();
System.out.println("Enter any interior angle: ");
double a = sc.nextDouble();
// converting values to radians
double b = Math.toRadians(a);
double area=side*side*(Math.sin(b));
if (side <= 0)
System.out.println("Length should be positve");
else
System.out.println("Area of rhombus = "+ area);
}
}
输入菱形任意一边的长度:2
输入任意内角:30
菱形的面积= 1.99999999999
Java 程序：给定半径求圆面积
在本教程中，我们将学习如何使用递归函数找到两个数字的乘积。递归函数是调用自身的函数。但是在继续之前，如果你不熟悉 java 中嵌套 if 语句的概念，那么一定要查看主题为【Java 中的 T0】条件语句的文章。
输入:输入圆的半径:7.5
输出:圆的面积为:176.78
程序 1:计算和显示圆的面积
在这个程序中，我们将看到在给定半径的情况下如何计算圆的面积。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储半径。
-
要求用户初始化变量。
-
使用公式计算圆的面积。
-
打印结果。
-
停下来。
让我们看下面的程序来理解上面的算法。
//Java Program to find the area of a circle given the radius
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
int r;
double pi = 3.14, area;
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc = new Scanner(System.in);
System.out.println("Enter the radius of circle: ");
r = sc.nextInt();
area = pi * r * r;
System.out.println("The area of the circle: "+area);
}
}
输入圆的半径:9
圆的面积:254.34
程序 2:计算和显示圆的面积
在这个程序中，我们将看到如何使用继承来计算给定半径时圆的面积。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储半径。
-
要求用户初始化变量。
-
创建 Main 类的对象。
-
使用继承来寻找圆的面积。
-
打印圆的面积。
-
停止
让我们看下面的程序来理解上面的算法。
//Java Program to find the area of a circle given the radius
import java.util.Scanner;
class AreaOfCircle
{
double area;
void circle(double rad)
{
area= (22*rad*rad)/7;
}
}
public class Main extends AreaOfCircle
{
public static void main(String args[])
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner s= new Scanner(System.in);
System.out.println("Enter the radius of the circle: ");
double radius= s.nextDouble();
Main a=new Main();
a.circle(radius);
System.out.println("The area of the circle is: " + a.area);
}
}
输入圆的半径:5
圆的面积是:78。58860 . 88888888861
Java 程序：打印空心菱形星形图案
原文：https://www.studytonight.com/java-programs/java-program-to-print-the-hollow-rhombus-star-pattern
在本教程中，我们将看到如何在 Java 中打印空心菱形星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印空心菱形星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:4
输出:模式为:
程序 1:打印空心菱形星形图案
在这个程序中，我们将看到如何使用 for 循环在 Java 中打印空心菱形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数和模式符号。
- 要求用户初始化这些变量。
- 使用 for 循环打印图案。
- 在这个 for 循环中，使用另一个 for 循环来打印空格。
- 现在使用 if-else 语句打印模式。
- 在 if-else 语句中，再次使用 for 循环检查条件。
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program to print the Hollow Rhombus Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
System.out.println("Enter Symbol: ");
System.out.println("");
char c = sc.next().charAt(0);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n-i;j++)
{
System.out.print(" ");
}
if(i==1 || i==n)
for(int j=1;j<=n;j++)
{
System.out.print(c);
}
else
{
for(int j=1;j<=n;j++)
{
if(j==1 || j==n)
System.out.print(c);
else
System.out.print(" ");
}
}
System.out.println();
}
}
}
输入行数:7
输入符号:*
程序 2:打印空心菱形星形图案
在这个程序中，我们将看到如何使用 while 循环在 Java 中打印空心菱形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数和模式符号。
- 要求用户初始化这些变量。
- 使用 while 循环打印图案。
- 在这个 while 循环中，使用另一个 while 循环来打印空格。
- 现在使用 if-else 语句打印模式。
- 在 if-else 语句中，再次使用 while 循环检查条件。
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program to print the Hollow Rhombus Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
System.out.println("Enter Symbol: ");
System.out.println("");
char c = sc.next().charAt(0);
int i=1;
int j;
while(i<=n)
{
j=1;
while(j++<=n-i)
{
System.out.print(" ");
}
if(i==1 || i==n)
{
j=1;
while(j <=n)
{
System.out.print(c);
j++;
}
}
else
{
j=1;
while(j<=n)
{
if(j==1 || j==n)
System.out.print(c);
else
System.out.print(" ");
j++;
}
}
System.out.println();
i++;
}
}
}
输入行数:7
输入符号:*
Java 程序：打印空心镜像菱形星形图案
在本教程中，我们将看到如何在 Java 中打印中空镜像菱形星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印中空的镜像菱形星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:4
输出:模式为:
程序 1:打印空心镜像菱形
在这个程序中，我们将看到如何使用 for 循环打印中空镜像菱形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数和模式符号。
- 要求用户初始化这些变量。
- 使用 for 循环打印图案。
- 在这个 for 循环中，使用另外两个 for 循环和另一个 if-else 语句来打印模式。
- 使用第一个 for 循环打印空间，另一个 for 循环打印图案。
- 如果 if(i1 || in)为真，则 for 循环的结构为(int j = 1；j < = n；j++)并打印从 j=1 到 n 的字符。
- 如果为假，循环的结构为(int j = 1；j < = n；j++)并在 j=1 或 j=n 时打印字符，在 if j！=1 和 j！=n。
- 显示输出。
- 停止
下面的例子说明了上述算法的实现。
//Java Program To Print Hollow Mirrored Rhombus
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows : ");
int n=sc.nextInt();
System.out.println("Enter the Symbol : ");
char ch = sc.next().charAt(0);
for(int i=1;i<=n;i++)
{
for(int j=i;j>0;j--)
{
System.out.print(" ");
}
if(i==1 || i==n)
for(int j=1;j<=n;j++)
{
System.out.print(ch);
}
else
{
for(int j=1;j<=n;j++)
{
if(j==1 || j==n)
System.out.print(ch);
else
System.out.print(" ");
}
}
System.out.println();
}
}
}
输入行数:7
输入符号:*
程序 2:打印空心镜像菱形
在这个程序中，我们将看到如何使用 while 循环打印中空镜像菱形星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明变量来存储行数和模式符号。
-
要求用户初始化这些变量。
-
使用 while 循环打印图案。
-
检查给定值 I 的条件，当(i<=n)时，如果该条件为真，则 j 初始化为 1。
-
在这个 while 循环中，使用另外两个 while 循环和另一个 if-else 语句来打印模式。
-
如果 if(i1 || in)条件 a)为真，j=1，则内部 while 循环打印章程，直到 while 条件(j <=n)为假。b)false，当循环在 j=1 或 j=n 处打印 chart 时，转到 else 部分，直到 while(j<=n)条件为 false，在 j 处打印空格！=1 和 j！=n。
-
显示结果。
-
停下来。
下面的例子说明了上述算法的实现。
//Java Program To Print Hollow Mirrored Rhombus
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows : ");
int n=sc.nextInt();
System.out.println("Enter the Symbol : ");
char ch = sc.next().charAt(0);
int i=1;
int j;
while(i<=n)
{
j=i;
while(--j>0)
{
System.out.print(" ");
}
if(i==1 || i==n)
{
j=1;
while(j <=n)
{
System.out.print(ch);
j++;
}
}
else
{
j=1;
while(j<=n)
{
if(j==1 || j==n)
System.out.print(ch);
else
System.out.print(" ");
j++;
}
}
System.out.println();
i++;
}
}
}
输入行数:7
输入符号:*
程序 3:打印空心镜像菱形
在这个程序中，我们将看到如何使用 do-while 循环打印中空镜像菱形星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明变量来存储行数和模式符号。
-
要求用户初始化这些变量。
-
使用边做边循环打印图案。
-
对于给定的 I，j do 循环开始执行，内部 do 循环打印一个空格，然后检查 while 条件(–j > 0)，如果为真，则打印空格，直到 while 条件(–j > 0)为假。
-
检查 if 条件。如果为真，则内部 do 循环打印一个章程，然后在(+j<=n)时检查条件，直到(+j<=n)为假时打印条件。
-
如果为假，则转到 else 部分，对于 j=1，内部循环打印一个字符，然后检查条件，而(+j<=n)，则为假，因此打印空格，重复直到条件++j<=n 为假。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
//Java Program To Print Hollow Mirrored Rhombus
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows : ");
int n=sc.nextInt();
System.out.println("Enter the Symbol : ");
char ch = sc.next().charAt(0);
int i=1,j=1;
do
{
j=i;
do
{
System.out.print(" ");
}
while(--j>0);
if(i==1 || i==n)
{
j=1;
do
{
System.out.print(ch);
}
while(++j<=n);
}
else
{
j=1;
do
{
if(j==1 || j==n)
System.out.print(ch);
else
System.out.print(" ");
}while(++j<=n);
}
System.out.println();
++i;
} while(i<=n);
}
}
输入行数:8
输入符号:*
Java 程序：打印菱形星形图案
原文：https://www.studytonight.com/java-programs/java-program-to-print-rhombus-star-pattern
在本教程中，我们将看到如何在 Java 中打印菱形星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环打印菱形星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:4
输出:模式为:
程序 1:打印菱形星形图案
在这个程序中，我们将看到如何使用 for 循环在 java 中打印菱形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数和模式符号。
- 要求用户初始化这些变量。
- 使用 for 循环打印图案。
- 在这个 for 循环中，再使用两个 for 循环来打印所需的图案。
- 现在使用第一个 for 循环来打印空格。
- 使用第二个 for 循环打印图案。
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program to Print the Rhombus star pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n-i;j++)
{
System.out.print(" ");
}
for(int j=1;j<=n;j++)
{
System.out.print("*");
}
System.out.println();
}
}
}
输入行数:5
程序 2:打印菱形星形图案
在这个程序中，我们将看到如何使用 while 循环在 java 中打印菱形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数和模式符号。
- 要求用户初始化这些变量。
- 使用 while 循环打印图案。
- 在这个 while 循环中，再使用两个 while 循环来打印所需的图案。
- 现在使用第一个 while 循环来打印空格。
- 使用第二个 while 循环打印图案。
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program to Print the Rhombus star pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
while(i<=n)
{
int j=1;
while(j++<=n-i)
{
System.out.print(" ");
}
j=1;
while(j++<=n)
{
System.out.print("*");
}
System.out.println();
i++;
}
}
}
输入行数:7
程序 3:打印菱形星形图案
在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印菱形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数和模式符号。
- 要求用户初始化这些变量。
- 使用边做边循环打印图案。
- 在这个边做边循环中，再使用两个边做边循环来打印所需的图案。
- 现在使用第一个 do-while 循环打印空间。
- 使用第二个边做边循环打印图案。
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program to Print the Rhombus star pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
do
{
int j=1;
do
{
System.out.print(" ");
}while(j++<=n-i);
j=1;
do
{
System.out.print("*");
}while(j++<=n);
System.out.println();
i++;
} while(i<=n);
}
}
输入行数:8
-
-
-
-
-
-
- T2】* * * * * * * T3】* * * * * T4】* * * * * T5】* * * * * T6】* * * * * T7】* * * * * * * T8
-
-
-
-
-
Java 程序：打印 8 星图案
原文：https://www.studytonight.com/java-programs/java-program-to-print-8-star-pattern
在本教程中，我们将看到如何在 Java 中打印 8 星模式。首先，我们将要求用户初始化行数。然后，我们将使用不同的循环来打印 8 星图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:4
输出:模式为:
程序 1:打印 8 星图案
在这个程序中，我们将看到如何使用 for 循环在 java 中打印一个 8 星图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数。
- 要求用户初始化变量。
- 使用 for 循环打印图案。
- 在第一个内部循环中，从 j=1 迭代到 j=n，检查“if”条件，如果是真的，它将显示“space”，否则它会到达 else 部分并显示“*”符号。
- 如果第一个“如果”条件为假，那么将执行第二个内部 for 循环。在从 j=1 到 j=n 的第二次 for 循环迭代中，检查“if”条件如果为真，则显示“*”符号，否则显示“space”。
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program To Print 8 Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int k=n*2-1;
for(int i=1;i<=k;i++)
{
if(i==1 || i==n || i==k)
for(int j=1;j<=n;j++)
{
if(j==1 || j==n)
System.out.print(" ");
else
System.out.print("*");
}
else
for(int j=1;j<=n;j++)
{
if(j==1 || j==n)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
}
}
输入行数:7
程序 2:打印 8 星图案
在这个程序中，我们将看到如何使用 while 循环在 java 中打印一个 8 星图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明变量来存储行数。
-
要求用户初始化变量。
-
使用 while 循环打印图案。
-
在第一个内部 while 循环中，如果 while 的条件为真，则检查“if”条件，如果条件为真，则显示“space”，否则显示“*”，它将继续，直到内部 while 循环条件为假。
-
第二个内部 while 循环仅在外部 while 循环的 if 条件为 false 时执行，在第二个内部 while 循环中，首先检查 while 的条件，然后检查“if”条件，如果条件为 true，则显示“*”，否则显示“space”。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
//Java Program To Print 8 Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
int j;
int k=n*2-1;
while(i<=k)
{
if(i==1 || i==n || i==k)
{
j=1;
while(j<=n)
{
if(j==1 || j==n)
System.out.print(" ");
else
System.out.print("*");
j++;
}
}
else
{
j=1;
while(j<=n)
{
if(j==1 || j==n)
System.out.print("*");
else
System.out.print(" ");
j++;
}
}
System.out.println();
i++;
}
}
}
输入行数:8
Java 程序：程序 3:打印 8 星图案
在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印一个 8 星图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明变量来存储行数。
-
要求用户初始化变量。
-
使用边做边循环打印图案。
-
在第一个内部边做边循环中，如果“如果”条件为真，它将显示空格，否则它将显示“”，在第二个内部边做边循环中，如果“如果”条件为真，它将显示“”，否则它将显示空格。
-
外部 do-while 循环中的总代码将被执行，直到 while 条件为假，即 while(i<=k)。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
//Java Program To Print 8 Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
int j;
int k=n*2-1;
do
{
if(i==1 || i==n || i==k)
{
j=1;
do
{
if(j==1 || j==n)
System.out.print(" ");
else
System.out.print("*");
j++;
}while(j<=n);
}
else
{
j=1;
do
{
if(j==1 || j==n)
System.out.print("*");
else
System.out.print(" ");
j++;
}while(j<=n);
}
System.out.println();
i++;
}while(i<=k);
}
}
输入行数:6
Java 程序：打印倒星形图案
原文：https://www.studytonight.com/java-programs/java-program-to-print-inverted-star-pattern
在本教程中，我们将看到如何在 Java 中打印倒星形模式。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印倒置的星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:4
输出:模式为:
这可以通过使用以下方法来实现:
方法 1:使用 For 循环
方法 2:使用 While 循环
方法 3:使用边做边循环
让我们看看这些方法中的每一种，以便更好地理解
程序 1:打印倒星形图案
在这个程序中，我们将看到如何使用 for 循环在 java 中打印倒星形模式。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量来存储行数。
- 要求用户初始化变量。
- 使用 for 循环打印图案。
- 若要遍历行，请运行具有(int I = n；I > 0；I–)。
- 若要遍历行，请运行内部循环。
- 如果 i>0 && j
- 如果 i>0&&j
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program To Print Inverted Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
for(int i=n;i>0 ;i--)
{
for(int j=0;j<n-i;j++)
{
System.out.print(" ");
}
for(int j=0;j<(i*2)-1;j++)
{
System.out.print("*");
}
System.out.println();
}
}
}
输入行数:7
-
-
-
-
-
-
-
-
-
-
-
-
- T2】* * * * * * * * * * * T3】* * * * * * * * * T4】* * * * * * * * * T5】* * * * * T6
-
-
-
-
-
-
-
-
-
-
-
程序 2:打印倒星形图案
在这个程序中，我们将看到如何使用 while 循环在 java 中打印倒星形模式。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量来存储行数。
- 要求用户初始化变量。
- 使用 while 循环打印图案。
- Outer while 循环迭代，直到 i>0 为 false。
- 如果条件 j++
- 如果条件 j++
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program To Print the Inverted Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=n,j;
while(i>0)
{
j=0;
while(j++<n-i)
{
System.out.print(" ");
}
j=0;
while(j++<(i*2)-1)
{
System.out.print("*");
}
System.out.println();
i--;
}
}
}
输入行数:7
-
-
-
-
-
-
-
-
-
-
-
-
- T2】* * * * * * * * * * * T3】* * * * * * * * * T4】* * * * * * * * * T5】* * * * * T6
-
-
-
-
-
-
-
-
-
-
-
程序 3:打印倒星形图案
在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印倒星形模式。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明一个变量来存储行数。
- 要求用户初始化变量。
- 使用边做边循环打印图案。
- 外部 do-while 循环迭代，直到 while(–I > 0)为假。
- 第一个内部循环打印空格，直到条件 j++
- 第二个内部循环打印字符，直到条件 j++
- 显示结果。
- 停止
下面的例子说明了上述算法的实现。
//Java Program To Print the Inverted Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=n,j;
do
{
j=0;
do
{
System.out.print(" ");
}while(j++<n-i);
j=0;
do
{
System.out.print("*");
}while(j++<i*2-2);
System.out.println();
}while(--i>0);
}
}
输入行数:7
-
-
-
-
-
-
-
-
-
-
-
-
- T2】* * * * * * * * * * * T3】* * * * * * * * * T4】* * * * * * * * * T5】* * * * * T6
-
-
-
-
-
-
-
-
-
-
-
Java 程序：打印空心直角三角形星形图案
原文：https://www.studytonight.com/java-programs/java-program-to-print-hollow-right-triangle-star-pattern
在本教程中，我们将看到如何在 Java 中打印空心直角三角形星形图案。首先，我们将要求用户初始化行数。然后，我们将使用不同的循环来打印空心的直角三角形星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:4
输出:模式为:
程序 1:打印空心直角三角形星形图案
在这个程序中，我们将看到如何使用 for 循环在 java 中打印空心直角三角形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数。
- 要求用户初始化变量。
- 使用 for 循环打印图案。
- 使用(int I = 1；I < = n；i++)
- 外部 for 循环从 i=1 迭代到 n。
- 如果“If”条件为真，则第一个内部循环打印字符，直到 j<=i
- 如果“If”条件为 false，则第二个内部循环打印 j=1 或 j=i 的字符，直到 j<=i，代表 j！=1 和 j！=n 打印空间。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program To Print the Hollow Right Triangle Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
System.out.println("Enter the symbol: ");
char ch = sc.next().charAt(0);
for(int i=1;i<=n;i++)
{
if(i==1 || i==n)
for(int j=1;j<=i;j++)
{
System.out.print(ch);
}
else
{
for(int j=1;j<=i;j++)
{
if(j==1 || j==i)
System.out.print(ch);
else
System.out.print(" ");
}
}
System.out.println();
}
}
}
输入行数:7
输入符号:*
*
程序 2:打印空心直角三角形星形图案
在这个程序中，我们将看到如何使用 while 循环在 java 中打印空心直角三角形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数。
- 要求用户初始化变量。
- 使用 while 循环打印图案。
- 如果给定的“I”值为真，检查外侧的状况。
- 然后检查“如果”条件。如果为真，则将 j 初始化为 1，检查内部 while 条件 j<=i，如果为真则打印字符并增加 j 值，重复直到条件 j<=i 为假。
- 如果为假，则将 j 初始化为 1，检查 while 条件，条件为真则打印 j=1 或 j=i 的字符，否则打印 j 的空格！=i 和 j！=1.
- 重复，直到外侧的条件为假。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program To Print the Hollow Right Triangle Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
int j;
while(i<=n)
{
if(i==1 || i==n)
{
j=1;
while(j <=i)
{
System.out.print("*");
j++;
}
}
else
{
j=1;
while(j<=i)
{
if(j==1 || j==i)
System.out.print("*");
else
System.out.print(" ");
j++;
}
}
System.out.println();
i++;
}
}
}
输入行数:7
*
程序 3:打印空心直角三角形星形图案
在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印空心直角三角形星形图案。
算法:
- 开始
- 创建 Scanner 类的实例。
- 声明变量来存储行数。
- 要求用户初始化变量。
- 使用边做边循环打印图案。
- 检查 if 条件。
- 如果为真，则第一个内部 do 循环打印一个字符，然后在(++j <=i)时检查条件，如果此条件为真，则打印字符，重复直到条件为假。
- 如果为 false，则第二个内部循环打印 j=1 或 j=i 的字符，打印 j=1、j=i 值以外的空格。然后在(++j<=i)时检查条件；，重复直到条件为假。
- 在每次迭代中增加循环变量。
- 重复直到(I < = n)；是假的。
- 显示结果。
- 停下来。
下面的例子说明了上述算法的实现。
//Java Program To Print the Hollow Right Triangle Star Pattern
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
//Take input from the user
//Create an instance of the Scanner Class
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
int j;
do
{
if(i==1 || i==n)
{
j=1;
do
{
System.out.print("*");
}while(++j <=i);
}
else
{
j=1;
do
{
if(j==1 || j==i)
System.out.print("*");
else
System.out.print(" ");
}
while(++j<=i);
}
System.out.println();
++i;
} while(i<=n);
}
}
输入行数:8
*
Java 程序：打印空心菱形星形图案
原文：https://www.studytonight.com/java-programs/java-program-to-print-hollow-diamond-star-pattern
在本教程中，我们将看到如何在 Java 中打印空心菱形星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印空心钻石星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:4
输出:模式为:
这可以通过使用以下方法来实现:
方法 1:使用 For 循环
方法 2:使用 While 循环
方法 3:使用边做边循环
让我们看看这些方法中的每一种，以便更好地理解
程序 1:打印空心钻石星形图案
在这个程序中，我们将看到如何使用 for 循环在 java 中打印空心菱形星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用 for 循环打印图案。
-
第一个外部 for 循环将显示空心菱形图案的一半，第二个外部 for 循环将显示剩余的空心菱形图案。
-
第一个外部 for 循环执行该组语句，直到条件 i
-
下一秒内循环将被执行，直到条件为假。对于 i=0，空心图案的第一行完成。第一个 for 循环将显示此模式。
-
第二个外部 for 循环执行语句，直到条件为假。第一个内部循环执行语句，直到条件为假。在此循环中，如果“if”条件为真，则显示字符“*”，否则显示空格。
-
第二个内部循环执行该组语句，直到条件为假，在第二个内部循环中，如果“if”条件为真，则显示空格，否则显示字符“*”。第二个外环将显示此模式。
-
显示结果
下面的例子说明了上述算法的实现。
//Java Program to Print the Hollow Diamond Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(j<n-i)
System.out.print("*");
else
System.out.print(" ");
}
for(int j=0;j<n;j++)
{
if(j<i)
System.out.print(" ");
else
System.out.print("*");
}
System.out.println();
}
for(int i=1;i<=n;i++)
{
for(int j=0;j<n;j++)
{
if(j<i)
System.out.print("*");
else
System.out.print(" ");
}
for(int j=0;j<n;j++)
{
if(j<n-i)
System.out.print(" ");
else
System.out.print("*");
}
System.out.println();
}
}
}
输入行数:7
-
-
-
-
-
-
-
-
-
-
- T2】* * * * * * * * * * * * * T3】* * * * * * * * * T4】* * * * * * * * * T5】* * * * * * * T6】* * * * * T7】* *
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T10】* * * * * * * T11】* * * * * * * * * * * T12】* * * * * * * * * * * T13】* * * * * * * * * * * * * T14】* * * * * * * * * * * * * * * * * * * * * * *
-
-
-
程序 2:打印空心钻石星形图案
在这个程序中，我们将看到如何使用 while 循环在 java 中打印空心菱形星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用 while 循环打印图案。
-
第一个外部 while 循环将执行代码，直到条件为真。第一个内部 while 循环执行语句，直到条件 j
-
在第一个内部 while 循环中，如果 j
-
在第一个内部循环执行之后，第二个内部循环将执行这些语句，直到条件 j
-
第二个外部 while 循环将执行这些语句，直到条件 i<=n 为假。第一个内部循环执行语句，直到条件 j
-
在第一个内部循环执行之后，将执行第二个内部循环，直到条件 j
-
显示结果
-
停止
下面的例子说明了上述算法的实现。
//Java Program to Print the Hollow Diamond Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=0;
int j;
while(i<n)
{
j=0;
while(j<n)
{
if(j<n-i)
System.out.print("*");
else
System.out.print(" ");
j++;
}
j=0;
while(j<n)
{
if(j<i)
System.out.print(" ");
else
System.out.print("*");
j++;
}
System.out.println();
i++;
}
i=1;
while(i<=n)
{
j=0;
while(j<n)
{
if(j<i)
System.out.print("*");
else
System.out.print(" ");
j++;
}
j=0;
while(j<n)
{
if(j<n-i)
System.out.print(" ");
else
System.out.print("*");
j++;
}
System.out.println();
i++;
}
}
}
输入行数:7
-
-
-
-
-
-
-
-
-
-
- T2】* * * * * * * * * * * * * T3】* * * * * * * * * T4】* * * * * * * * * T5】* * * * * * * T6】* * * * * T7】* *
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T10】* * * * * * * T11】* * * * * * * * * * * T12】* * * * * * * * * * * T13】* * * * * * * * * * * * * T14】* * * * * * * * * * * * * * * * * * * * * * *
-
-
-
Java 程序：程序 3:打印空心钻石星形图案
在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印空心菱形星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用边做边循环打印图案。
-
第一个外部 do-while 循环将执行代码，直到条件 i
-
在第一个内部循环执行之后，将执行第二个内部循环，直到条件 j
-
将执行第二个外部 do-while 循环，直到条件 i<=n。第一个内部循环执行语句，直到条件为假。在这个循环中，如果条件 j
-
完成第一个内部循环后，将执行第二个内部循环，直到条件 j
-
显示结果
-
停止
下面的例子说明了上述算法的实现。
//Java Program to Print the Hollow Diamond Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=0;
int j;
do
{
j=0;
do
{
if(j<n-i)
System.out.print("*");
else
System.out.print(" ");
j++;
}while(j<n);
j=0;
do
{
if(j<i)
System.out.print(" ");
else
System.out.print("*");
j++;
}while(j<n);
System.out.println();
i++;
} while(i<n);
i=1;
do
{
j=0;
do
{
if(j<i)
System.out.print("*");
else
System.out.print(" ");
j++;
} while(j<n);
j=0;
do
{
if(j<n-i)
System.out.print(" ");
else
System.out.print("*");
j++;
}while(j<n);
System.out.println();
i++;
}while(i<=n);
}
}
输入行数:7
-
-
-
-
-
-
-
-
-
-
- T2】* * * * * * * * * * * * * T3】* * * * * * * * * T4】* * * * * * * * * T5】* * * * * * * T6】* * * * * T7】* *
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- T10】* * * * * * * T11】* * * * * * * * * * * T12】* * * * * * * * * * * T13】* * * * * * * * * * * * * T14】* * * * * * * * * * * * * * * * * * * * * * *
-
-
-
Java 程序：检测链表中的循环
原文：https://www.studytonight.com/java-programs/java-program-to-detect-a-loop-in-a-linked-list
在本教程中，我们将看到如何在 java 中检测链表中的循环。LinkedList 是一种线性数据结构，其中元素不存储在连续的位置，每个元素都是一个单独的对象，具有数据部分和地址部分。每个元素都被称为一个节点。由于插入和删除的动态性和容易性，它们比数组更受欢迎。但是在继续之前，如果你不熟悉 java 中链表的概念，那么一定要查看一下 Java 中链表上的文章。
输入:输入链表元素:6 7 8 4 5
输出:环路找到
这可以通过使用以下方法来实现:
方法 1:使用HashSet
方法 2:不使用HashSet
让我们看看这些方法中的每一种，以便更好地理解。
程序 1:检测链表中的循环
在这个程序中，我们将看到如何使用哈希方法检测链表中的循环。
算法:
- 开始
- 创建链表。
- 向列表中添加元素。
- 使用布尔方法检查循环是否存在。
- 为此使用
HashSet。 - 逐一遍历列表，并不断将节点地址放入
HashSet中。 - 在任何时候，如果达到 null，则返回 false。
- 如果下一个当前节点指向 HashSet 中任何先前存储的节点，则返回 true。
- 显示结果。
- 停止
让我们看看下面的例子，以更好地理解上述算法。
// Java program to detect loop in a linked list
import java.util.*;
public class LinkedList
{
static Node head; // head of list
/* Linked list Node*/
static class Node {
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
static public void add(int newData)
{
Node newNode = new Node(newData);
newNode.next = head;
head = newNode;
}
static boolean checkLoop(Node n)
{
HashSet<Node> hset = new HashSet<Node>();
while (n != null) {
if (hset.contains(n))
return true;
hset.add(n);
n = n.next;
}
return false;
}
//Driver program
public static void main(String[] args)
{
LinkedList ll = new LinkedList();
ll.add(8);
ll.add(12);
ll.add(15);
ll.add(21);
ll.head.next.next.next.next = ll.head;
if (checkLoop(head))
System.out.println("Loop found");
else
System.out.println("No Loop found");
}
}
找到循环
程序 2:检测链表中的循环
在这个程序中，我们将看到如何检测链表中的循环。
算法:
- 开始
- 创建链表。
- 创建链表。
- 向列表中添加元素。
- 使用布尔方法检查循环是否存在。
- 声明一个临时变量并将其初始化为 0。
- 遍历链表并继续标记被访问的节点。
- 如果再次找到一个被访问的节点，那么就会出现一个循环。
- 显示结果。
- 停止
让我们看看下面的例子，以更好地理解上述算法。
// Java program to detect loop in a linked list
import java.util.*;
public class Main
{
static class Node
{
int data;
Node next;
int temp;
};
static Node add(Node newHead, int newData)
{
Node newNode = new Node();
newNode.data = newData;
newNode.temp = 0;
newNode.next = newHead;
newHead = newNode;
return newHead;
}
static boolean detect(Node n)
{
while (n != null)
{
if (n.temp == 1)
return true;
n.temp = 1;
n = n.next;
}
return false;
}
// Driver code
public static void main(String[] args)
{
Node head = null;
head = add(head, 20);
head = add(head, 4);
head = add(head, 15);
head = add(head, 10);
head.next.next.next.next = head;
if (detect(head))
System.out.print("Loop found");
else
System.out.print("No Loop found");
}
}
找到循环
Java 程序：打印半菱形星形图案
原文：https://www.studytonight.com/java-programs/java-program-to-print-half-diamond-star-pattern
在本教程中，我们将看到如何在 Java 中打印半菱形星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印半菱形星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:7
输出:模式为:
这可以通过使用以下方法来实现:
方法 1:使用 For 循环
方法 2:使用 While 循环
方法 3:使用边做边循环
让我们看看这些方法中的每一种，以便更好地理解
程序 1:打印半菱形星形图案
在这个程序中，我们将看到如何使用 for 循环在 java 中打印半菱形星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用 for 循环打印图案。
-
外部循环遍历行，内部循环遍历列
-
第一个外部 for 循环将打印半菱形图案的一半，第二个外部 for 循环将打印半菱形图案的剩余一半。
-
循环的第一个外部循环迭代，直到条件 i<=n 为假，内部循环将显示字符，直到条件 j
-
第二个外部 for 循环迭代，直到条件 i>0 为假，内部循环将显示字符，直到 j<=i，第二个外部 for 循环将打印此模式。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
//Java Program to Print the Half Diamond Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < i + 1; j++)
System.out.print("*");
System.out.print("\n");
}
for (i = 1; i < n; i++)
{
for (j = i; j < n; j++)
System.out.print("*");
System.out.print("\n");
}
}
}
输入行数:4
*
程序 2:打印半菱形星形图案
在这个程序中，我们将看到如何使用 while 循环在 java 中打印半菱形星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用 while 循环打印图案。
-
第一个 while 循环迭代，直到 i<=n。
-
将内部循环变量初始化为 1。内部 while 循环将迭代直到 j++<=n。如果条件满足，它将打印模式。
-
第二个 while 循环迭代，直到 i>0。
-
将内部循环变量初始化为 1。内部 while 循环将迭代直到 j++<=i。如果条件满足，它将打印模式。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
//Java Program to Print the Half Diamond Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1,j;
while(i<=n)
{
j=1;
while(j++<=i)
{
System.out.print("*");
}
System.out.println();
i++;
}
i=n-1;
while(i>0)
{
j=1;
while(j++<=i)
{
System.out.print("*");
}
System.out.println();
i--;
}
}
}
输入行数:7
*
程序 3:打印半菱形星形图案
在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印半菱形星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用两个边做边循环来打印图案。
-
第一个 do-while 循环迭代，直到 l ++i<=n。
-
将内部循环变量初始化为 1。内部 do-while 循环将迭代直到++j<=i。如果条件满足，它将打印模式。
-
第二个 do-while 循环迭代，直到- i>0。
-
将内部循环变量初始化为 1。内部 do-while 循环将迭代直到++j<=i。如果条件满足，它将打印模式。
-
显示结果。
-
停止
下面的例子说明了上述算法的实现。
//Java Program to Print the Half Diamond Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
int j;
do
{
j=1;
do
{
System.out.print("*");
}while(++j<=i);
System.out.println();
} while(++i<=n);
i=n-1;
do
{
j=1;
do
{
System.out.print("*");
}while(++j<=i);
System.out.println();
} while(--i>0);
}
}
输入行数:7
*
Java 程序：打印空心金字塔星形图案
原文：https://www.studytonight.com/java-programs/java-program-to-print-the-hollow-pyramid-star-pattern
在本教程中，我们将看到如何在 Java 中打印空心金字塔星形图案。首先，我们将要求用户初始化行数。然后，我们将使用循环来打印空心金字塔星形图案。但是在继续之前，如果你不熟悉 java 中循环的概念，那么一定要查看关于 Java 中循环的文章。
输入:输入行数:4
输出:模式为:
这可以通过使用以下方法来实现:
方法 1:使用 For 循环
方法 2:使用 While 循环
方法 3:使用边做边循环
让我们看看这些方法中的每一种，以便更好地理解。
Java 程序：程序 1:打印空心金字塔星形图案
在这个程序中，我们将看到如何使用 for 循环在 java 中打印空心金字塔星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用 for 循环打印图案。
-
使用外部 for 循环迭代从 1 到 n 的行。
-
使用第一个内部 for 循环从 1 迭代到 n，然后打印所需的空间。
-
在中使用另一个 for 循环来打印所需的空间。
-
使用 if-else 语句打印所需的模式。
-
如果“If”条件为真，则使用从 1 迭代到 i*(2-1)的 for 循环，并打印星形符号。
-
如果“If”条件为假，则下一个 for 循环打印 if(j1 || ji*2-1)条件为真的字符。否则，它会打印空间。
-
显示模式。
-
停下来。
下面的例子说明了上述算法的实现。
//Java Program to Print the Hollow Pyramid Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n-i;j++)
{
System.out.print(" ");
}
if(i==1 || i==n)
for(int j=1;j<=i*2-1;j++)
{
System.out.print("*");
}
else
{
for(int j=1;j<=i*2-1;j++)
{
if(j==1 || j==i*2-1)
System.out.print("*");
else
System.out.print(" ");
}
}
System.out.println();
}
}
}
输入行数:8
*
Java 程序：程序 2:打印空心金字塔星形图案
在这个程序中，我们将看到如何使用 while 循环在 java 中打印空心金字塔星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用 while 循环打印图案。
-
使用外部 while 循环进行迭代，直到 i<=n。
-
使用内部 while 循环遍历列。
-
在外层，使用另一个 if 条件打印所需的空间。
-
如果 if(i1 || in)条件为真，则第一个内部循环将打印字符，直到 j++<=i*2-1 条件为真。
-
如果条件为假，则如果(j1 || j(i2)-1)为真，则第二个内部循环打印字符，直到 while(j<=(i2)-1)为假，否则打印空格。
-
显示模式。
-
停下来。
下面的例子说明了上述算法的实现。
//Java Program to Print the Hollow Pyramid Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
int j;
while(i<=n)
{
j=1;
while(j++<=n-i)
{
System.out.print(" ");
}
if(i==1 || i==n)
{
j=1;
while(j++<=i*2-1)
{
System.out.print("*");
}
}
else
{
j=1;
while(j<=(i*2)-1)
{
if(j==1 || j==(i*2)-1)
System.out.print("*");
else
System.out.print(" ");
j++;
}
}
System.out.println();
i++;
}
}
}
输入行数:7
*
Java 程序：程序 3:打印空心金字塔星形图案
在这个程序中，我们将看到如何使用 do-while 循环在 java 中打印空心金字塔星形图案。
算法:
-
开始
-
创建 Scanner 类的实例。
-
声明一个变量来存储行数。
-
要求用户初始化变量。
-
使用边做边循环打印图案。
-
第一个内部 do-while 循环将迭代，直到条件++j <=n-i+1
-
在外部 do-while 内部，使用另一个 if 条件打印所需的空间。
-
如果“如果”条件为真，则内部边做边循环打印章程，直到条件(++j <=i*2-1)为假。
-
如果“If”条件为假，则下一个 do-while 循环打印 chart if if(j = = 1 | | j = = I * 2-1)为真，直到 while(+j < = I * 2-1)为假，否则打印空格。
-
显示模式。
-
停下来。
下面的例子说明了上述算法的实现。
//Java Program to Print the Hollow Pyramid Star Pattern
import java.util.*;
public class Main
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the number of rows: ");
int n=sc.nextInt();
int i=1;
int j;
do
{
j=1;
do
{
System.out.print(" ");
}while(++j <=n-i+1);
if(i==1 || i==n)
{
j=1;
do
{
System.out.print("*");
}while(++j <=i*2-1);
}
else
{
j=1;
do
{
if(j==1 || j==i*2-1)
System.out.print("*");
else
System.out.print(" ");
}while(++j<=i*2-1);
}
System.out.println();
++i;
} while(i<=n);
}
}
输入行数:7
*
Java 程序：使用关系运算符
原文：https://www.studytonight.com/java-programs/java-program-to-use-relational-operators
在本教程中，我们将学习如何执行关系操作。Java 中的关系运算符用于比较等式、小于、大于等变量。它总是返回一个布尔变量。但是在继续之前，如果您不熟悉 java 中关系运算符的概念，那么一定要查看关于 Java 中运算符的文章。
输入:输入第一个数字(num1): 6
输入第二个数字(num2): 2
输出:
==之后的结果是:假
结果之后！=是:真的
num1>num2 后的结果:真
num1
num1>=num2 后的结果:真
num1<=num2 后的结果:假
上述问题可以通过以下方式解决:
方法 1:当值被预定义时
方法 2:当值由用户定义时
让我们分别看看这些方法。
程序 1:执行关系操作
在这个程序中，我们将在程序中预定义值时执行关系操作。
算法:
- 开始
- 这里，我们将使用 switch case 从不同的关系运算符中进行选择，如==，！=，，<= and > =。
- 声明两个变量。
- 初始化它。
- 执行所有关系运算符，如==，！=，，<= and > =。
- 显示每个关系操作的结果。
- 停下来。
让我们看看下面的例子，以便更好地理解。
//Java Program to perform relational operations
public class Main
{
public static void main(String args[])
{
//Declare and initialize the variables
int a = 6;
System.out.println("The entered value of a is " + a);
int b = 2;
System.out.println("The entered value of b is " + b);
//Perform relational operations
System.out.println("Values of Relational Operations: ");
System.out.println("The result of a == b is " + (a == b) );
System.out.println("The result of a != b is " + (a != b) );
System.out.println("The result of a > b is " + (a > b) );
System.out.println("The result of a < b is " + (a < b) );
System.out.println("The result of b >= a is " + (b >= a) );
System.out.println("The result of b <= a is " + (b <= a) );
}
}
a 的输入值为 6
b 的输入值为 2
关系运算的值:
a = = b 的结果为假
a 的结果！= b 为真
a>b 的结果为真
a<b 的结果为假
b>a 的结果为假
b<a 的结果为真
程序 2:执行关系操作
在这个程序中，我们将通过接收用户的输入来执行关系操作。
算法:
- 开始
- 这里，我们将使用 switch case 从不同的关系运算符中进行选择，如==，！=，，<= and > =。
- 为相同的声明一个变量。
- 请用户初始化它。
- 根据选择的操作，声明两个变量。
- 要求用户初始化变量。
- 执行关系操作后显示结果。
- 停下来。
让我们看看下面的例子，以便更好地理解。
//Java program to perform Relational Operators
import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
while(true)
{
System.out.println("");
System.out.println("Choose the operation you want to perform ");
System.out.println("Choose 1 for == ");
System.out.println("Choose 2 for != ");
System.out.println("Choose 3 for > ");
System.out.println("Choose 4 for < ");
System.out.println("Choose 5 for <= ");
System.out.println("Choose 6 for >= ");
System.out.println("Choose 7 for EXIT");
int n = s.nextInt();
switch(n)
{
case 1:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int a = s.nextInt();
System.out.print("Enter the second number : ");
int b = s.nextInt();
System.out.println("The result after == is: "+(a == b));
break;
case 2:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int p = s.nextInt();
System.out.print("Enter the second number : ");
int q = s.nextInt();
System.out.println("The result after != is: "+(p != q));
break;
case 3:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int x = s.nextInt();
System.out.print("Enter the second number : ");
int y = s.nextInt();
System.out.println("The result after > is : "+(x > y));
break;
case 4:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int c = s.nextInt();
System.out.print("Enter the second number : ");
int d = s.nextInt();
System.out.print("The result after < is : "+(c < d));
break;
case 5:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int e = s.nextInt();
System.out.print("Enter the second number : ");
int f = s.nextInt();
System.out.println("The result after >= : "+(e >= f));
break;
case 6:
System.out.println("Enter the two numbers to perform operations ");
System.out.print("Enter the first number : ");
int g = s.nextInt();
System.out.print("Enter the second number : ");
int h = s.nextInt();
System.out.println("The result after <= : "+(g <= h));
break;
case 7:
System.exit(0);
}
}
}
}
选择要执行的操作
选择 1 =选择=
选择 2！=
选择 3 代表>
选择 4 代表<
选择 5 代表< =
选择 6 代表> =
选择 7 代表退出
1
输入两个数字执行操作
输入第一个数字:3
输入第二个数字:2
之后的结果==为:假
选择要执行的操作
选择 1 代表==
选择 2 代表=
选择 3 为>
选择 4 为<
选择 5 为< =
选择 6 为> =
选择 7 为退出
4
输入两个数字执行操作
输入第一个数字:2
输入第二个数字:7
在<后的结果为:真
选择要执行的操作
选择 1 为==
选择=
选择 3 表示>
选择 4 表示<
选择 5 表示< =
选择 6 表示> =
选择 7 表示退出
7
标签：教程,Java,int,System,println,java,StudyTonight,public,out From： https://www.cnblogs.com/apachecn/p/18500113