Ik ben nieuw in Java. Hoe het Java-equivalent van de volgende C-code te schrijven.
void Swap(int *p, int *q)
{
int temp;
temp = *p;
*p = *q;
*q = temp;
}
Antwoord 1, autoriteit 100%
Hier is een truc:
public static int getItself(int itself, int dummy)
{
return itself;
}
public static void main(String[] args)
{
int a = 10;
int b = 20;
a = getItself(b, b = a);
}
Antwoord 2, autoriteit 44%
Twee ints sorteren
Het korte antwoord is: dat kan niet, java heeft geen aanwijzingen.
Maar hier is iets soortgelijks dat u kunt doen:
public void swap(AtomicInteger a, AtomicInteger b){
// look mom, no tmp variables needed
a.set(b.getAndSet(a.get()));
}
Je kunt dit doen met allerlei soorten containerobjecten (zoals verzamelingen en arrays of aangepaste objecten met een int-eigenschap), maar niet met primitieven en hun wrappers (omdat ze allemaal onveranderlijk zijn). Maar de enige manier om er een oneliner van te maken is met AtomicInteger, denk ik.
BTW: als je gegevens toevallig een lijst zijn, is een betere manier om te ruilen het gebruik van Collections.swap(List, int, int):
Swaps the elements at the specified positions in the specified list.
(If the specified positions are equal, invoking this method leaves
the list unchanged.)
Parameters:
list - The list in which to swap elements.
i - the index of one element to be swapped.
j - the index of the other element to be swapped.
Sorteren van een INT [] array
Blijkbaar is het echte doel om een reeks inten te sorteren.
Dat is een one-liner met Arrays.sort(int[]):
int[] arr = {2,3,1,378,19,25};
Arrays.sort(arr);
Om de uitvoer te controleren:
System.out.println(Arrays.toString(arr));
// [1, 2, 3, 19, 25, 378]
en hier is een eenvoudige helperfunctie om twee posities in een array van inten te ruilen:
public static void swap(final int[] arr, final int pos1, final int pos2){
final int temp = arr[pos1];
arr[pos1] = arr[pos2];
arr[pos2] = temp;
}
Antwoord 3, Autoriteit 40%
Hier is een methode om twee variabelen in Java in slechts één regel te ruilen met Bitwise XOR (^) -operator .
class Swap
{
public static void main (String[] args)
{
int x = 5, y = 10;
x = x ^ y ^ (y = x);
System.out.println("New values of x and y are "+ x + ", " + y);
}
}
output:
Nieuwe waarden van X en Y zijn 10, 5
Antwoord 4, Autoriteit 11%
Gebruik deze one-liner voor elke primitieve nummerklasse inclusief doubleen float:
a += (b - (b = a));
Bijvoorbeeld:
double a = 1.41;
double b = 0;
a += (b - (b = a));
System.out.println("a = " + a + ", b = " + b);
Uitvoer is a = 0.0, b = 1.41
Antwoord 5, autoriteit 5%
Er zijn geen verwijzingen in Java. Elke variabele die een object “bevat” is echter een verwijzingnaar dat object. Om uitvoerparameters te hebben, zou u objecten moeten gebruiken. In jouw geval, Integer-objecten.
Dus je zou een object moeten maken dat een geheel getal bevat en dat geheel getal moet veranderen. U kunt de klasse Integer niet gebruiken, omdat deze onveranderlijk is (d.w.z. de waarde ervan kan niet worden gewijzigd).
Een alternatief is om de methode een array of paar ints te laten retourneren.
Antwoord 6, autoriteit 3%
In dat soort gevallen is er een snelle en vuile oplossing met arrays met één element:
public void swap(int[] a, int[] b) {
int temp = a[0];
a[0] = b[0];
b[0] = temp;
}
Natuurlijk moet je code ook met deze arrays werken, wat onhandig is. De array-truc is handiger als je een lokale eindvariabele van een innerlijke klasse wilt wijzigen:
public void test() {
final int[] a = int[]{ 42 };
new Thread(new Runnable(){ public void run(){ a[0] += 10; }}).start();
while(a[0] == 42) {
System.out.println("waiting...");
}
System.out.println(a[0]);
}
Antwoord 7, autoriteit 3%
Hoe zit het met de machtige IntHolder? Ik ben dol op elk pakket met omg in de naam!
import org.omg.CORBA.IntHolder;
IntHolder a = new IntHolder(p);
IntHolder b = new IntHolder(q);
swap(a, b);
p = a.value;
q = b.value;
void swap(IntHolder a, IntHolder b) {
int temp = a.value;
a.value = b.value;
b.value = temp;
}
Antwoord 8, autoriteit 2%
Snippet-1
public int[] swap1(int[] values) {
if (values == null || values.length != 2)
throw new IllegalArgumentException("parameter must be an array of size 2");
int temp = values[0];
values[0]=values[1];
values[1]=temp;
return values;
}
Snippet-2
public Point swap2(java.awt.Point p) {
if (p == null)
throw new NullPointerException();
int temp = p.x;
p.x = p.y;
p.y = temp;
return p;
}
Gebruik:
int[] values = swap1(new int[]{x,y});
x = values[0];
y = values[1];
Point p = swap2(new Point(x,y));
x = p.x;
y = p.y;
Antwoord 9, autoriteit 2%
Java gebruikt pass-by-value. Het is niet mogelijk om twee primitieven of objectenom te wisselen met een methode.
Hoewel het mogelijk is om twee elementen in een integerarray om te wisselen.
Antwoord 10
Je kunt geen referenties gebruiken in Java, dus een swap-functie is onmogelijk, maar je kunt het volgende codefragment gebruiken voor elk gebruik van swap-bewerkingen:
T t = p
p = q
q = t
waarbij T het type p en q is
Het verwisselen van veranderlijke objecten kan echter mogelijk zijn door eigenschappen te herschrijven:
void swap(Point a, Point b) {
int tx = a.x, ty = a.y;
a.x = b.x; a.y = b.y;
b.x = t.x; b.y = t.y;
}
Antwoord 11
je moet het inline doen. Maar je hebt die ruil echt niet nodig in Java.
Antwoord 12
Uw swap-functie verandert in wezen de waarden in twee geheugen. Alleen alles verwijzend naar die bits van het geheugen krijgt nu verschillende waarden.
In Java zijn er geen echt aanwijzingen, dus dit zal niet werken. In plaats daarvan worden referenties op objecten gehouden en kunt u alleen dingen in de objecten veranderen. Als u een object op twee plaatsen moet noemen, zodat u dezelfde waarden rond het systeem kunt passeren en dingen laten reageren op hen, probeer dan iets als het repository patroon of afhankelijkheid injectie .
We kunnen alleen maar raden waarom je deze code in C nodig had in C. Het enige advies dat ik kan geven, is om na te denken over de wijzigingen in de objecten die je wilt bereiken, bij voorkeur een methode toevoegen aan de eigenlijke objecten in plaats van hun internals te trekken uit en bel die methode in plaats daarvan. Als dit u niet helpt, probeer dan de roepcode te plaatsen zoals we waarschijnlijk een goed idee hebben van het oplossen van het echte probleem Java-stijl.
Antwoord 13
Java is per waarde. Dus de swapIn de zin dat u bedoelt, is niet mogelijk. Maar u kunt inhoud van twee objecten wisselen of u doet het inline.
Antwoord 14
U kunt variabelen wisselen met of zonder een tijdelijke variabele te gebruiken.
Hier is een artikel dat meerdere methoden biedt om nummers te wisselen zonder TEMP-variabele:
Antwoord 15
je kunt jezelf gemakkelijk schrijven.
gegeven:
int array[]={1,2};
jij doet:
int temp=array[0];
array[0]=array[1];
array[1]=temp;
En je bent klaar. 3 regels code.
Antwoord 16
Verwisselen met behulp van pointeris nietmogelijk in Java. U kunt echterswapping implementeren door een array door te gevendie twee objecten bevat.
Code gaat als volgt:
public class Swap {
public static void swap(String [] a){
String temp;
temp = a[0];
a[0] = a[1];
a[1] = temp;
}
public static void main(String [] args){
String [] foo = new String[2];
foo[0] = "str1";
foo[1] = "str2";
swap(foo);
System.out.println("First value: "+ foo[0]);
System.out.println("Second value: "+ foo[1]);
}
}
Uitvoer:
First value: str2
Second value: str1
Antwoord 17
public class swaptemp {
public static void main(String[] args) {
String s1="10";
String s2="20";
String temp;
System.out.println(s1);
System.out.println(s2);
temp=Integer.toString(Integer.parseInt(s1));
s1=Integer.toString(Integer.parseInt(s2));
s2=Integer.toString(Integer.parseInt(temp));
System.out.println(s1);
System.out.println(s2);
}
}
Antwoord 18
//here is also another answer:
class SwapDemo{
static int a=1, b=2 ;
public static void main(String [] args){
Swap swp = new Swap();
swp.swaps(x,y);
System.out.println( " a (was 1)now is " + a + " b (was 2) now is " + b);
}
}
class Swap{
void swaps(int c, int d){
SwapDemo f = new SwapDemo();
f.a = c;
f.a = d;
}
}
Antwoord 19
class Swap2Values{
public static void main(String[] args){
int a = 20, b = 10;
//before swaping
System.out.print("Before Swapping the values of a and b are: a = "+a+", b = "+b);
//swapping
a = a + b;
b = a - b;
a = a - b;
//after swapping
System.out.print("After Swapping the values of a and b are: a = "+a+", b = "+b);
}
}