Develop Reference

Instance of object over riding another instance of the object java

This is for a school project In this version of the card game WAR when a tie occurs one card is faced down however my issue is occurring in the first 30 lines of code in which playerTwo is over-ridding and duplicating itself onto playerOne so that when I test my code playerOne and playerTwo are continuously 'tied'.
public class War {
public static WarQueue playerTwo;
public static WarQueue playerOne;
public static void main(String[] args) throws FileNotFoundException {
Scanner temp = new Scanner(new File("war.txt"));
{
/*String one = temp.nextLine();
String two = temp.nextLine();*/
String[] a = temp.nextLine().split(" ");
playerOne = new WarQueue(a);
String[] b = temp.nextLine().split(" ");
playerTwo = new WarQueue(b);
for (int i = 0; i < 26; i++) {
playerOne.enqueue(a[i]);
}
System.out.println(playerOne.toString());
for (int i = 0; i < 26; i++) {
playerTwo.enqueue(b[i]);
}
System.out.println(playerOne.toString());
System.out.println(playerTwo.toString());
System.out.println(playerTwo.peek());
System.out.println(playerOne.peek());
System.out.println(playerOne.peek() + " " + playerTwo.peek());
int hand = hand(playerOne.peek(), playerTwo.peek());
if (hand == 1) {
playerOne.enqueue(playerOne.dequeue());
playerOne.enqueue(playerTwo.dequeue());
System.out.println(playerOne.peek());
} else if (hand == 2) {
playerTwo.enqueue(playerTwo.dequeue());
playerTwo.enqueue(playerOne.dequeue());
System.out.println(playerTwo.peek());
} else {
ArrayList<String> warCards = new ArrayList<>();
String first = null;
String second = null;
int win = 0;
do {
String down1 = playerOne.dequeue();
String down2 = playerTwo.dequeue();
first = playerOne.dequeue();
second = playerTwo.dequeue();
warCards.add(down1);
warCards.add(down2);
warCards.add(first);
warCards.add(second);
win = hand(first, second);
} while (win == 10);
if (win == 1) {
for (String card : warCards) {
playerOne.enqueue(card);
}
} else if (win == 2) {
for (String card : warCards) {
playerTwo.enqueue(card);
}
}
warCards.clear();
}
if (playerOne.size() == 52) {
System.out.println("player 1 wins");
} else {
System.out.println("player 2 wins");
}
} while (temp.hasNextLine());
}
static int hand(String one, String two) {
String[] card = one.split("");
String[] card2 = two.split("");
int cardOne = 0;
int cardTwo = 0;
int win = 0;
switch (card[0]) {
case "T":
cardOne = 10;
break;
case "J":
cardOne = 11;
break;
case "Q":
cardOne = 12;
break;
case "K":
cardOne = 13;
break;
case "A":
cardOne = 14;
break;
case "2":
cardOne = 2;
break;
case "3":
cardOne = 3;
break;
case "4":
cardOne = 4;
break;
case "5":
cardOne = 5;
break;
case "6":
cardOne = 6;
break;
case "7":
cardOne = 7;
break;
case "8":
cardOne = 8;
break;
case "9":
cardOne = 9;
break;
}
switch (card2[0]) {
case "T":
cardTwo = 10;
break;
case "J":
cardTwo = 11;
break;
case "Q":
cardTwo = 12;
break;
case "K":
cardTwo = 13;
break;
case "A":
cardTwo = 14;
break;
case "2":
cardTwo = 2;
break;
case "3":
cardTwo = 3;
break;
case "4":
cardTwo = 4;
break;
case "5":
cardTwo = 5;
break;
case "6":
cardTwo = 6;
break;
case "7":
cardTwo = 7;
break;
case "8":
cardTwo = 8;
break;
case "9":
cardTwo = 9;
break;
}
if (cardOne > cardTwo)
win = 1;
if (cardTwo > cardOne)
win = 2;
if (cardOne == cardTwo)
win = 10;
return win;
}
}
this is my WarQueue class
public class WarQueue {
/**
* Created by 148439 on 9/4/2018.
*/
public static String[] ringBuffer;
int front = 0;
int size = 0;
WarQueue(String[] a )
{
ringBuffer = new String[a.length];
}// create an empty ring buffer, with given max capacity
int size()
{
return size;
}// return number of items currently in the buffer
boolean isEmpty()
{
return size() == 0;
}// is the buffer empty (size equals zero)?
boolean isFull()
{
return size() == ringBuffer.length;
}
// buffer full (size equals capacity)?
void enqueue(String b)
{
if (isFull()) {
return;
}
ringBuffer[(front + size()) % ringBuffer.length] = String.valueOf(b);
size++;
}// add item x to the end
String dequeue()
{
if (isEmpty())
return null;
String pos = ringBuffer[front];
front = (front + 1) % ringBuffer.length;
size--;
return pos;
}// delete and return item from the front
String peek()
{
if (isEmpty())
{
return null;
}
return ringBuffer[front];
}
void empty() {
ringBuffer = new String[ringBuffer.length];
front = 0;
size = 0;
}
public String toString()
{
String str = "";
for(int i = 0; i < ringBuffer.length; i++)
{
str = str + " " + ringBuffer[i];
}
return str;
}
}
this code prints out that playerOne and playerTwo are the same but when tested in their own for loops they are diffrent until after the second for loop ends.

Evaluating Expression in java

I am getting output impossible.
but it must be possible.
when i check at the editor it shows that that the case is always true
i.e last three cases of switch.
public String isPossible(String express) {
char a = ' ';
char b = ' ';
boolean flag = true;
Stack<Character> pile = new Stack<Character>();
char [] array = express.toCharArray();
for (int i = 0 ; i < array.length ; i++) {
a = array[i];
switch (a) {
case '(':
pile.push(a);
break;
case '{':
pile.push(a);
break;
case '[':
pile.push(a);
break;
case ')':
b = pile.pop();
if (b != '(' || b != 'X')
flag = false;
break;
case '}':
b = pile.pop();
if (b != '{' || b != 'X')
flag = false;
break;
case ']':
b = pile.pop();
if (b != ']' || b != 'X')
flag = false;
break;
}
}
if (flag == false || pile.size() % 2 != 0)
return "impossible";
else
return "possible";
}
public static void main(String args[]) {
Merge a = new Merge();
System.out.println(a.isPossible("(())"));
}

Your logic is incorrectly using the || (or) operator. It is always true that b is not '(' or it's not 'X'. You want && (and).
Replace
if(b!='(' || b!= 'X')
with
if(b!='(' && b!= 'X')
and similarly for the other if conditions in the case statements.

Method to check higher precendence of operators, Is there a smarter way to do this?

Here's a method I wrote to check which operator has the highest precedence, now my question is: is there any other way I can do this? I have been testing this one and it works fine, but I'm pretty sure there should be room for improvement. What do you think?
static boolean hasHigherPrecendence(char top, char current){
String t = String.valueOf(top);
String c = String.valueOf(current);
System.out.println(t);
System.out.println(c);
switch (t) {
case "-":
if ( c.equals("-") || c.equals("+") )
return false;
break;
case "+":
if ( c.equals("-") || c.equals("+") )
return false;
break;
case "/":
if ( !c.equals("*") || !c.equals(t) || !c.equals("%") )
return false;
break;
case "*":
if ( !c.equals("%") || !c.equals(t) || !c.equals("/"))
return false;
break;
case "%":
if (c.equals(t) || c.equals("*") || c.equals("/"))
return false;
break;
default:
throw new IllegalArgumentException("Operator unknown: " + t);
}
return true;
}

If it were me I would rank the operators in a function (note, the values I chose are not necessarily the ones you should use ...):
private static final int rankOperator(char op) {
switch (op) {
case '-' : return 0;
case '+' : return 0;
case '/' : return 2;
case '*' : return 2;
case '%' : return 4;
}
throw new IllegalStateException("Unknown operator " + op);
}
public boolean hasHigherPrecedence(char top, char current) {
return rankOperator(top) > rankOperator(current);
}

Apart of using maps, arrays, functions... you can reduce your code using the concatenating the cases with the same behaviour:
static boolean hasHigherPrecendence(char top, char current){
String t = String.valueOf(top);
String c = String.valueOf(current);
System.out.println(t);
System.out.println(c);
switch (t) {
case "-":
case "+":
if ( c.equals("-") || c.equals("+") )
return false;
break;
case "/":
case "*":
case "%":
if (c.equals("%") || c.equals("*") || c.equals("/"))
return false;
break;
default:
throw new IllegalArgumentException("Operator unknown: " + t);
}
return true;
}

static boolean hasHigherPrecendence(char top, char current){
Map<Character,Integer> map = new HashMap<>();
map.put('+',new Integer(1));
map.put('-',new Integer(1));
map.put('*',new Integer(2));
map.put('/',new Integer(2));
map.put('%',new Integer(3));
if( map.get(top)==null ){
throw new IllegalArgumentException("Operator unknown: " + top);
}
if( map.get(current)==null ){
throw new IllegalArgumentException("Operator unknown: " + current);
}
if(map.get(t) >= map.get(c)){
return true;
}else{
return false;
}
}

how to convert a char array back into string [duplicate]

This question already has answers here:
How to convert a char array back to a string?
(14 answers)
Closed 9 years ago.
i am doing a porter stemmer.....the code gives me output in char array....but i need to convert that into string to proceed with futher work.....in the code i have given 2 words "looking" and "walks"....that is returned as look and walk(but in char array)...the output is printed in stem() function
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package file;
import java.util.Vector;
/**
*
* #author sky
*/
public class stemmer {
public static String line1;
private char[] b;
private int i, /* offset into b */
i_end, /* offset to end of stemmed word */
j, k;
private static final int INC = 50;
/* unit of size whereby b is increased */
public stemmer()
{
//b = new char[INC];
i = 0;
i_end = 0;
}
/**
* Add a character to the word being stemmed. When you are finished
* adding characters, you can call stem(void) to stem the word.
*/
public void add(char ch)
{
System.out.println("in add() function");
if (i == b.length)
{
char[] new_b = new char[i+INC];
for (int c = 0; c < i; c++)
new_b[c] = b[c];
b = new_b;
}
b[i++] = ch;
}
/** Adds wLen characters to the word being stemmed contained in a portion
* of a char[] array. This is like repeated calls of add(char ch), but
* faster.
*/
public void add(char[] w, int wLen)
{ if (i+wLen >= b.length)
{
char[] new_b = new char[i+wLen+INC];
for (int c = 0; c < i; c++)
new_b[c] = b[c];
b = new_b;
}
for (int c = 0; c < wLen; c++)
b[i++] = w[c];
}
public void addstring(String s1)
{
b=new char[s1.length()];
for(int k=0;k<s1.length();k++)
{
b[k] = s1.charAt(k);
System.out.println(b[k]);
}
i=s1.length();
}
/**
* After a word has been stemmed, it can be retrieved by toString(),
* or a reference to the internal buffer can be retrieved by getResultBuffer
* and getResultLength (which is generally more efficient.)
*/
public String toString() { return new String(b,0,i_end); }
/**
* Returns the length of the word resulting from the stemming process.
*/
public int getResultLength() { return i_end; }
/**
* Returns a reference to a character buffer containing the results of
* the stemming process. You also need to consult getResultLength()
* to determine the length of the result.
*/
public char[] getResultBuffer() { return b; }
/* cons(i) is true <=> b[i] is a consonant. */
private final boolean cons(int i)
{ switch (b[i])
{ case 'a': case 'e': case 'i': case 'o': case 'u': return false;
case 'y': return (i==0) ? true : !cons(i-1);
default: return true;
}
}
/* m() measures the number of consonant sequences between 0 and j. if c is
a consonant sequence and v a vowel sequence, and <..> indicates arbitrary
presence,
<c><v> gives 0
<c>vc<v> gives 1
<c>vcvc<v> gives 2
<c>vcvcvc<v> gives 3
....
*/
private final int m()
{ int n = 0;
int i = 0;
while(true)
{ if (i > j) return n;
if (! cons(i)) break; i++;
}
i++;
while(true)
{ while(true)
{ if (i > j) return n;
if (cons(i)) break;
i++;
}
i++;
n++;
while(true)
{ if (i > j) return n;
if (! cons(i)) break;
i++;
}
i++;
}
}
/* vowelinstem() is true <=> 0,...j contains a vowel */
private final boolean vowelinstem()
{ int i; for (i = 0; i <= j; i++) if (! cons(i)) return true;
return false;
}
/* doublec(j) is true <=> j,(j-1) contain a double consonant. */
private final boolean doublec(int j)
{ if (j < 1) return false;
if (b[j] != b[j-1]) return false;
return cons(j);
}
/* cvc(i) is true <=> i-2,i-1,i has the form consonant - vowel - consonant
and also if the second c is not w,x or y. this is used when trying to
restore an e at the end of a short word. e.g.
cav(e), lov(e), hop(e), crim(e), but
snow, box, tray.
*/
private final boolean cvc(int i)
{ if (i < 2 || !cons(i) || cons(i-1) || !cons(i-2)) return false;
{ int ch = b[i];
if (ch == 'w' || ch == 'x' || ch == 'y') return false;
}
return true;
}
private final boolean ends(String s)
{
int l = s.length();
int o = k-l+1;
if (o < 0)
return false;
for (int i = 0; i < l; i++)
if (b[o+i] != s.charAt(i))
return false;
j = k-l;
return true;
}
/* setto(s) sets (j+1),...k to the characters in the string s, readjusting
k. */
private final void setto(String s)
{ int l = s.length();
int o = j+1;
for (int i = 0; i < l; i++)
b[o+i] = s.charAt(i);
k = j+l;
}
/* r(s) is used further down. */
private final void r(String s) { if (m() > 0) setto(s); }
/* step1() gets rid of plurals and -ed or -ing. e.g.
caresses -> caress
ponies -> poni
ties -> ti
caress -> caress
cats -> cat
feed -> feed
agreed -> agree
disabled -> disable
matting -> mat
mating -> mate
meeting -> meet
milling -> mill
messing -> mess
meetings -> meet
*/
private final void step1()
{
if (b[k] == 's')
{ if (ends("sses")) k -= 2; else
if (ends("ies")) setto("i"); else
if (b[k-1] != 's') k--;
}
if (ends("eed")) { if (m() > 0) k--; } else
if ((ends("ed") || ends("ing")) && vowelinstem())
{ k = j;
if (ends("at")) setto("ate"); else
if (ends("bl")) setto("ble"); else
if (ends("iz")) setto("ize"); else
if (doublec(k))
{ k--;
{ int ch = b[k];
if (ch == 'l' || ch == 's' || ch == 'z') k++;
}
}
else if (m() == 1 && cvc(k)) setto("e");
}
}
/* step2() turns terminal y to i when there is another vowel in the stem. */
private final void step2() { if (ends("y") && vowelinstem()) b[k] = 'i'; }
/* step3() maps double suffices to single ones. so -ization ( = -ize plus
-ation) maps to -ize etc. note that the string before the suffix must give
m() > 0. */
private final void step3() { if (k == 0) return; /* For Bug 1 */ switch (b[k-1])
{
case 'a': if (ends("ational")) { r("ate"); break; }
if (ends("tional")) { r("tion"); break; }
break;
case 'c': if (ends("enci")) { r("ence"); break; }
if (ends("anci")) { r("ance"); break; }
break;
case 'e': if (ends("izer")) { r("ize"); break; }
break;
case 'l': if (ends("bli")) { r("ble"); break; }
if (ends("alli")) { r("al"); break; }
if (ends("entli")) { r("ent"); break; }
if (ends("eli")) { r("e"); break; }
if (ends("ousli")) { r("ous"); break; }
break;
case 'o': if (ends("ization")) { r("ize"); break; }
if (ends("ation")) { r("ate"); break; }
if (ends("ator")) { r("ate"); break; }
break;
case 's': if (ends("alism")) { r("al"); break; }
if (ends("iveness")) { r("ive"); break; }
if (ends("fulness")) { r("ful"); break; }
if (ends("ousness")) { r("ous"); break; }
break;
case 't': if (ends("aliti")) { r("al"); break; }
if (ends("iviti")) { r("ive"); break; }
if (ends("biliti")) { r("ble"); break; }
break;
case 'g': if (ends("logi")) { r("log"); break; }
} }
/* step4() deals with -ic-, -full, -ness etc. similar strategy to step3. */
private final void step4() { switch (b[k])
{
case 'e': if (ends("icate")) { r("ic"); break; }
if (ends("ative")) { r(""); break; }
if (ends("alize")) { r("al"); break; }
break;
case 'i': if (ends("iciti")) { r("ic"); break; }
break;
case 'l': if (ends("ical")) { r("ic"); break; }
if (ends("ful")) { r(""); break; }
break;
case 's': if (ends("ness")) { r(""); break; }
break;
} }
/* step5() takes off -ant, -ence etc., in context <c>vcvc<v>. */
private final void step5()
{ if (k == 0) return; /* for Bug 1 */ switch (b[k-1])
{ case 'a': if (ends("al")) break; return;
case 'c': if (ends("ance")) break;
if (ends("ence")) break; return;
case 'e': if (ends("er")) break; return;
case 'i': if (ends("ic")) break; return;
case 'l': if (ends("able")) break;
if (ends("ible")) break; return;
case 'n': if (ends("ant")) break;
if (ends("ement")) break;
if (ends("ment")) break;
/* element etc. not stripped before the m */
if (ends("ent")) break; return;
case 'o': if (ends("ion") && j >= 0 && (b[j] == 's' || b[j] == 't')) break;
/* j >= 0 fixes Bug 2 */
if (ends("ou")) break; return;
/* takes care of -ous */
case 's': if (ends("ism")) break; return;
case 't': if (ends("ate")) break;
if (ends("iti")) break; return;
case 'u': if (ends("ous")) break; return;
case 'v': if (ends("ive")) break; return;
case 'z': if (ends("ize")) break; return;
default: return;
}
if (m() > 1) k = j;
}
/* step6() removes a final -e if m() > 1. */
private final void step6()
{ j = k;
if (b[k] == 'e')
{ int a = m();
if (a > 1 || a == 1 && !cvc(k-1)) k--;
}
if (b[k] == 'l' && doublec(k) && m() > 1) k--;
}
/** Stem the word placed into the Stemmer buffer through calls to add().
* Returns true if the stemming process resulted in a word different
* from the input. You can retrieve the result with
* getResultLength()/getResultBuffer() or toString().
*/
public void stem()
{
// step1();
// System.out.println("hello in stem");
// step2();
// step3();
// step4();
// step5();
// step6();
//
// i_end = k+1;
// i = 0;
System.out.println(i);
k = i - 1;
if (k > 1)
{
step1();
step2();
step3();
step4();
step5();
step6();
}
for(int c=0;c<=k;c++)
System.out.println(b[c]);
i_end = k+1; i = 0;
}
public static void main(String[] args)
{
stemmer s = new stemmer();
s.addstring("looking");
s.stem();
s.addstring("walks");
s.stem();
//System.out.println("Output " +s.b);
}
}

- Use Character class method toString();
Eg:
class Test
{
public static void main (String[] args) throws java.lang.Exception
{
char c = 'a';
String s = Character.toString(c);
System.out.println(s);
}
}
- Now use this above explained method to convert all the character array items into String.

char[] data = new char[10];
String text = String.valueOf(data);

to convert a char[] to string use this way
String x=new String(char[])
example
char x[]={'a','m'};
String z=new String(x);
System.out.println(z);
output
am

char[] a = new char[10];
for(int i=0;i<10;i++)
{
a[i] = 's';
}
System.out.println(new String(a));
or
System.out.println(String.copyValueOf(a));

java infix calculator

I cant seem to get the inside of the try block to make stacks, I am meant to get a calculator with single digit by using stacks inside the try block. The inside of the try block is giving me emptystackexception
import java.util.EmptyStackException;
import java.util.*;
public class Infix
{
public static void main(String[] args){
System.out.println(evaluateInfix("1*2*3"));
}
public static double evaluateInfix(String infix)
{
try
{
Stack<Character> valueStack = new Stack<Character> ();
Stack<Character> operatorStack = new Stack<Character> ();
double result;
for(char ch: infix.toCharArray()){
if(ch >= 0 && ch <= 9){
valueStack.push(ch);
} else if(ch == '('){
operatorStack.push(ch);
} else if(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '%' || ch == '^' || ch == '='){
if(operatorStack.isEmpty()){
operatorStack.push(ch);
} else if(precedence(ch) > precedence(operatorStack.peek())){
operatorStack.push(ch);
} else {
while(!operatorStack.isEmpty() && precedence(ch) <= precedence(operatorStack.peek())){
result = compute(valueOf(valueStack.pop()), valueOf(valueStack.pop()), operatorStack.pop());
valueStack.push((char)result);
}
operatorStack.push(ch);
}
} else if(ch == ')'){
while(operatorStack.peek() != '('){
result = compute(valueOf(valueStack.pop()), valueOf(valueStack.pop()), operatorStack.pop());
valueStack.push((char)result);
}
operatorStack.pop();
}
}
while(!operatorStack.isEmpty()){
result = compute(valueOf(valueStack.pop()), valueOf(valueStack.pop()), operatorStack.pop());
valueStack.push((char)result);
}
result = valueStack.peek();
System.out.println(result);
/* **********
Task 3
complete this section to calculate the infix expression
*/
} //end try
catch (EmptyStackException e)
{
/* **********
Task 3
complete this to return Double.NaN
*/
}
catch (ArithmeticException e)
{
/* **********
Task 3
complete this to return Double.NEGATIVE_INFINITY
*/
}
return 3.0;
} // end evaluateInfix
private static int precedence(char operator)
{
switch(operator){
case '(': case ')': return 0;
case '+': case '-': return 1;
case '*': case '/': case '%': return 2;
case '^': return 3;
case '=': return 4;
}
return -1;
}
private static double valueOf(char variable)
{
switch (variable)
{
case '1': return 1.0;
case '2': return 2.0;
case '3': return 3.0;
case '4': return 4.0;
case '5': return 5.0;
case '6': return 6.0;
case '7': return 7.0;
case '8': return 8.0;
case '9': return 9.0;
case '0': return 0.0;
} // end switch
return 0;
} // end valueOf
private static Double compute(Double operandOne, Double operandTwo, char operator)
{
if(operator == '+'){
return operandOne + operandTwo;
} else if(operator == '-'){
return operandOne - operandTwo;
} else if(operator == '*'){
return operandOne * operandTwo;
} else if(operator == '/'){
return operandOne / operandTwo;
} else if(operator == '%'){
return operandOne % operandTwo;
} else if(operator == '^'){
return Math.pow(operandOne, operandTwo);
} else {
return null;
}
} // end compute
} // end Infix

Shouldn't the first if contain '' around the numbers?
if(ch >= '0' && ch <= '9'){

You have a redundant pair of "}" and "{" which turn the bulk of your code into an initialization block - essentially a constructor of the Infix class.
(Based on your comment) - there is a missing method declaration.
Try changing the first few lines from:
public class Infix {
public static void main(String[] args){
System.out.println(evaluateInfix("1*2*3"));
}
{
try {
...
to:
public class Infix {
public static void main(String[] args){
System.out.println(evaluateInfix("1*2*3"));
}
public static double evaluateInfix(String infix) {
try {
...