import java.util.Random;
import java.util.Scanner;
public class Main{
static int maxOf(int[] a) {
int max = a[0];
for (int i = 1; i < a.length; i++)
if (a[i] > max)
max = a[i];
return max;
}
public static void main(String[] args) {
Random rand = new Random();
Scanner stdIn = new Scanner(System.in);
System.out.print("사람 수 : ");
int num = stdIn.nextInt(); // 배열의 요솟수를 입력 받음
int[] height = new int[num]; // 요솟수가 num인 배열을 생성
System.out.println("키 값은 아래와 같습니다.");
for (int i = 0; i < num; i++) {
height[i] = 100 + rand.nextInt(90); // 요소의 값을 난수로 결정
System.out.println("height[" + i + "]：" + height[i]);
}
System.out.println("최댓값은 " + maxOf(height) + "입니다.");
}
}
/*
사람 수 : 18
키 값은 아래와 같습니다.
height[0]：145
height[1]：186
height[2]：129
height[3]：175
height[4]：136
height[5]：161
height[6]：111
height[7]：142
height[8]：181
height[9]：126
height[10]：178
height[11]：100
height[12]：113
height[13]：132
height[14]：122
height[15]：127
height[16]：106
height[17]：185
최댓값은 186입니다.
*/
1~100개의 데이터 수를 랜덤으로 생성한 후, 0~10000의 데이터를 랜덤으로 입력한 후 최댓값 출력
import java.util.Random;
public class Main{
static int maxOf(int[] arr) {
int max = arr[0];
for(int i = 1; i < arr.length; ++i)
{
if(max < arr[i]) max = arr[i];
}
return max;
}
public static void main(String[] args) {
Random rand = new Random();
int num = rand.nextInt(1,101);
int[] arr = new int[num];
for (int i = 0; i < arr.length; i++) {
arr[i] = rand.nextInt(10001);
System.out.print(i + "번째 원소의 값 : ");
System.out.println(arr[i]);
}
System.out.println("최댓값은 " + maxOf(arr) + "입니다.");
}
}
/*
0번째 원소의 값 : 8929
1번째 원소의 값 : 5458
2번째 원소의 값 : 8705
3번째 원소의 값 : 1236
4번째 원소의 값 : 5730
5번째 원소의 값 : 5667
6번째 원소의 값 : 9866
7번째 원소의 값 : 946
8번째 원소의 값 : 9884
9번째 원소의 값 : 4317
10번째 원소의 값 : 1018
11번째 원소의 값 : 5090
12번째 원소의 값 : 306
13번째 원소의 값 : 3743
14번째 원소의 값 : 58
15번째 원소의 값 : 6879
16번째 원소의 값 : 5951
17번째 원소의 값 : 5974
최댓값은 9884입니다.
*/
본 게시글은 혼자 공부하는 자바 (저자 : 신용권)의 책과 유튜브 영상을 참고하였고, 개인적으로 정리하는 글임을 알립니다.
System 클래스
자바 프로그램은 JVM위에서 실행된다. java.lang 패키지에 속하는 System 클래스의 정적 필드와 메소드를 이용하면 프로그램 종료, 키보드 입력, 콘솔(모니터) 출력, 현재 시간 읽기, 시스템 프로퍼티 읽기 등이 가능하다.
System 클래스의 모든 필드와 메소드는 정적 필드와 정적 메소드로 구성되어 있다.
정적 멤버
용도
필드
out
콘솔에 문자 출력
err
콘솔에 에러 내용 출력(빨간 글자색)
in
키보드 입력
메소드
exit(int status)
프로세스 종료(JVM 종료)
currentTimeMillis()
현재 시간을 밀리초 단위의 long 값으로 리턴
nanoTime()
현재 시간을 나노초 단위의 long 값으로 리턴
getProperty()
운영체제와 사용자 정보 제공
getenv()
운영체제의 환경 변수 정보 제공
콘솔 출력
out을 이용하면 콘솔에 원하는 문자열을 출력할 수 있다.
err도 out과 동일한데, 차이점은 콘솔 종류에 따라 에러 내용이 빨간색으로 출력된다는 것이다.
public class ErrExample {
public static void main(String[] args) {
try {
int value = Integer.parseInt("1oo");
} catch(NumberFormatException e) {
System.err.println("[에러 내용]");
System.err.println(e.getMessage());
}
}
}
키보드 입력
자바는 키보드로부터 입력된 키를 읽기 위해 System 클래스에서 in 필드를 제공한다.
다음과 같이 in 필드를 이용해서 read() 메소드를 호출하면 입력된 키의 코드값을 얻을 수 있다.
출처 : 이것이 자바다 유튜브 동영상 강의
read() 메소드는 호출과 동시에 키 코드를 읽는 것이 아니라, 엔터키를 눌기 전까지는 대기상태이다가 엔터키를 누르면 입력했던 키들을 하나씩 읽기 시작한다.
단 read() 메소드는 IO 예외를 발생할 수 있는 코드이므로 예외처리가 필요하다.
아래의 예제는 숫자 키 1과 2를 입력함에 따라 speed 변수값을 증감하는 예제이다. 3을 누르면 종료
public class InExample {
public static void main(String[] args) throws Exception {
int speed = 0;
int keyCode = 0;
while(true) {
if(keyCode != 13 && keyCode != 10) { //Enter 키를 읽지 않았을 경우에만 실행
if (keyCode == 49) { //숫자 1 키를 읽었을 경우
speed++;
} else if (keyCode == 50) { //숫자 2 키를 읽었을 경우
speed--;
} else if (keyCode == 51) { //숫자 3 키를 읽었을 경우
break;
}
System.out.println("-----------------------------");
System.out.println("1. 증속 | 2. 감속 | 3. 중지");
System.out.println("-----------------------------");
System.out.println("현재 속도= " + speed);
System.out.print("선택: ");
}
//키를 하나씩 읽음
keyCode = System.in.read();
}
System.out.println("프로그램 종료");
}
}
/*
-----------------------------
1. 증속 | 2. 감속 | 3. 중지
-----------------------------
현재 속도= 0
선택: 1
-----------------------------
1. 증속 | 2. 감속 | 3. 중지
-----------------------------
현재 속도= 1
선택: 2
-----------------------------
1. 증속 | 2. 감속 | 3. 중지
-----------------------------
현재 속도= 0
선택: 1
-----------------------------
1. 증속 | 2. 감속 | 3. 중지
-----------------------------
현재 속도= 1
선택: 1
-----------------------------
1. 증속 | 2. 감속 | 3. 중지
-----------------------------
현재 속도= 2
선택: 1
-----------------------------
1. 증속 | 2. 감속 | 3. 중지
-----------------------------
현재 속도= 3
선택: 1
-----------------------------
1. 증속 | 2. 감속 | 3. 중지
-----------------------------
현재 속도= 4
선택: 1
-----------------------------
1. 증속 | 2. 감속 | 3. 중지
-----------------------------
현재 속도= 5
선택: 3
프로그램 종료
*/
프로그램 종료(exit())
경우에 따라서 강제적으로 JVM을 종료시킬 때도 있다. 이때 System클래스의 exit()메소드를 호출하면 된다.
exit()메소드는 int 매개값을 지정하도록 되어 있는데, 이 값을 종료 상태값이라고 한다. 일반적으로 정상 종료일 경우 0값을 준다.
비정상 종료는 1또는 -1로 주는 것이 관례이다.
System.exit(0); // JVM(프로그램) 강제종료 코드
현재 시각 읽기(currentTimeMillis(), nanoTime())
System 클래스의 currentTimeMillis(), nanoTime() 메소드는 컴퓨터의 시계로부터 현재 시간을 읽어서 밀리세컨드(1/1000초) 단위와 나노세컨드(1/10^9초) 단위의 long 값을 리턴한다.
리턴값은 주로 프로그램의 실행 소요 시간 측정에 사용된다.
아래의 코드는 1부터 100만까지의 합을 구하는데 걸린 시간을 출력하는 코드이다.
public class Main {
public static void main(String[] args) {
long time1 = System.nanoTime();
int sum = 0;
for(int i=1; i<=1000000; i++) {
sum += i;
}
long time2 = System.nanoTime();
System.out.println("1~1000000까지의 합 : " + sum);
System.out.println("계산에 " + (time2-time1) + " 나노초가 소요됨");
System.out.println((time2-time1)/(10e9));
}
}
/*
1~1000000까지의 합 : 1784293664
계산에 2873700 나노초가 소요됨
2.8737E-4
*/
2.8737 * 10^-4 = 0.00028737초가 소요된 것을 알 수 있다.
시스템 프로퍼티(System Property) 읽기
시스템 프로퍼티란 자바 프로그램이 시작될 때 자동 설정되는 시스템의 속성을 말한다.
예를 들어 운영체제 종류 및 사용자 정보, 자바 버전 등의 기본 사양 정보가 해당한다.
속성 이름(key)
설명
java.specification.version
자바 스펙 버전
java.home
JDK 디렉토리 경로
os.name
운영체제
user.name
사용자 이름
user.home
사용자 홈 디렉토리 경로
user.dir
현재 디렉토리 경로
import java.util.Properties;
import java.util.Set;
public class GetPropertyExample {
public static void main(String[] args) {
//운영체제와 사용자 정보 출력
String osName = System.getProperty("os.name");
String userName = System.getProperty("user.name");
String userHome = System.getProperty("user.home");
System.out.println(osName);
System.out.println(userName);
System.out.println(userHome);
//전체 키와 값을 출력
System.out.println("---------------------------------");
System.out.println(" key: value");
System.out.println("---------------------------------");
Properties props = System.getProperties();
Set keys = props.keySet();
for(Object objKey : keys) {
String key = (String) objKey;
String value = System.getProperty(key);
System.out.printf("%-40s: %s\n", key, value);
}
}
}
/*
Windows 11
Lee
C:\Users\Lee
---------------------------------
key: value
---------------------------------
java.specification.version : 17
sun.cpu.isalist : amd64
sun.jnu.encoding : MS949
java.class.path : D:\프로그래밍\Eclipse\thisisjava\bin;D:\프로그래밍\Eclipse\thisisjava\lib\lombok.jar
java.vm.vendor : Oracle Corporation
sun.arch.data.model : 64
user.variant :
java.vendor.url : https://java.oracle.com/
java.vm.specification.version : 17
os.name : Windows 11
....
....
더 많다
*/
Class 클래스
자바는 클래스와 인터페이스의 메타 데이터를 java.lang 패키지에 소속된 Class로 관리한다.
메타 데이터란 클래스의 이름, 생성자 정보, 필드 정보, 메소드 정보를 말한다.
Class 객체얻기(getClass(), forName())
Class 객체를 얻기 위해서 아래의 세 가지 방법 중 하나를 이용하면 된다.
//how1
Class clazz = String.class;
//how2
Class clazz2 = Class.forName("java.lang.String");
//how3
String str = new String();
Class clazz3 = str.getClass();
아래의 코드는 모두 같은 클래스를 얻어서 전체이름, 간단한 이름, 패키지의 이름을 출력하는 코드이다.
모두 같은 Class 객체를 얻었기 때문에 출력결과가 같다.
public class Main {
public static void main(String[] args) throws ClassNotFoundException {
//how1
Class clazz = String.class;
//how2
Class clazz2 = Class.forName("java.lang.String");
//how3
String str = new String();
Class clazz3 = str.getClass();
System.out.println(clazz.getName()); //전체이름
System.out.println(clazz.getSimpleName()); // 간단한 이름
System.out.println(clazz.getPackage().getName()); // 패키지이름
System.out.println();
System.out.println(clazz2.getName()); //전체이름
System.out.println(clazz2.getSimpleName()); // 간단한 이름
System.out.println(clazz2.getPackage().getName()); // 패키지이름
System.out.println();
System.out.println(clazz3.getName()); //전체이름
System.out.println(clazz3.getSimpleName()); // 간단한 이름
System.out.println(clazz3.getPackage().getName()); // 패키지이름
}
}
/*
java.lang.String
String
java.lang
java.lang.String
String
java.lang
java.lang.String
String
java.lang
*/
클래스 경로를 활용해서 리소스 절대 경로 얻기
Class 객체는 해당 클래스의 파일 경로 정보를 가지고 있기 때문에 이 경로를 활용해서 다른 리소스 파일의 경로를 얻을 수 있다.
TestPackage 폴더 안에는 bin폴더, Main.java, file1.jpg가 있고, bin 폴더 안에는 file2.jpg가 있다.
public class Main {
public static void main(String[] args){
Class clazz = Main.class;
String photo1Path = clazz.getResource("file1.jpg").getPath();
String photo2Path = clazz.getResource("bin/file2.jpg").getPath();
System.out.println(photo1Path);
System.out.println(photo2Path);
}
}s
/*
/C:/Users/Lee/eclipse-workspace/TestProject/bin/TestPackage/file1.jpg
/C:/Users/Lee/eclipse-workspace/TestProject/bin/TestPackage/bin/file2.jpg
*/
위 코드는 Main.class를 기준으로 한 상대 경로를 이용해서 절대경로를 얻는 코드이다.
본 게시글은 유튜브 : 경제 TV 너무경 : 너무 쉬운 경제 윤성종 님의 유튜브 영상을 참고하였습니다. 개인적으로 정리하는 글임을 알립니다.
금융용어정리 - 유상감자
유상감자
무상감자와 달리 유상감자는 주주에게 보상을 하고 자본금을 줄이는 행위이다.
유상감자는 다음과 같은 특징을 가진다.
자본의 효율성을 높인다.
주식수는 감소하나 지분비율은 변하지 않음
주식수가 감소한다.
주주에게 자본금과 이익을 돌려준다.
주식시장에서 호재로 작용(돈 많은 기업이 효율성을 높임)
자본의 효율성을 높인다 자본의 효율성이 높다는 뜻은 재테크로 예를 들면 A씨와 B씨는 재테크로 연 10억을 번다. 하지만 A씨는 100억을 가지고 이익을 내지만, B씨는 1000억을 가지고 이익을 낸다. 같은 10억을 벌지만 그 10억을 벌기 위해 받쳐주는 돈이 다른 것이다. 즉, 효율은 A씨가 높은 것이다. 기업은 자본의 효율성을 높이기 위해 해당 사업에 투자하는 비용을 줄여서 줄인 돈으로 다른 것을 하는 것이다.
주식수는 감소하나 지분비율은 변하지 않음 예를 들어 액면가 10원, 자본금 4만 원으로 설립한 기업이 있다. 총 주식의 수는 400주이고, A씨는 300(3만원)주를 가지고 있고, B씨는 100주(만원)를 가지고 있다. 이 상태에서 2:1 유상감자를 진행하면 모든 주주가 같은 비율로 주식이 감소한다. A씨는 150주(만 오천원), B씨는 50주(오천원)로 주식수가 감소하였지만 지분 비율은 똑같다.
주식수 감소, 주주에게 자본금과 이익(잉여금)을 돌려줌 자본금 천만원, 잉여금, 5천만원, 액면가 천원, 주가 3천원, 주식 수 1만주인 기업이 있다고 하자 2:1 유상감자를 진행하여 주주에게 주당 3천원의 보상을 해준다고 하면 총 5000주의 주식이 감소하게 되는데, 주주에게 주는 총 보상액은 5000주 X 3000원 = 1500만원이다. 1500만원중 500만원(액면가 X 5천주)은 자본금 감소이고, 1000만원((주가-액면가) X 5천주)은 잉여금의 감소이다. 유상감자가 진행됨으로서 자본금은 5백만원, 잉여금은 4천만원, 주식수는 5천주로 감소하였다. 유상감자 전에는 자본이 6천만원이었고, 유상감자 후엔 자본이 4500만원이 되었다.
주식시장에서 호재로 작용 돈이 많아서 기업이 효율성을 높이기 위해 유상 감자를 진행한다고 생각하기 때문에 호재로 작용 총 주식의 수가 감소함으로 인해 주식 1주의 가치가 오름(의결권 강화)
설명 C언어 계열에서 printf문법과 같다. %3d는 총 자리수가 3이고 오른쪽 정렬을 한다는 뜻이다. 예를 들어 %d에 3을 넣으면 단순히 3이 출력되지만, %3d에 3을 넣으면 공백 2번 + 3이 출력된다. 반대로 %-3d에 3을 넣으면 3 + 공백 2번이 출력된다.
곱셈표 심화
위와 같이 |, -, + 를 사용하여 위쪽과 왼쪽에 곱하는 수가 있는 곱셈표를 출력하는 프로그램을 작성
import java.util.Scanner;
public class Main{
static void square(int n)
{
for(int i = 0; i < n; ++i){for(int j = 0; j < n; ++j) {System.out.print("*");}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("단 수 입력 : ");
int n = sc.nextInt();
square(n);
}
}
/*
단 수 입력 : 5
*****
*****
*****
*****
*****
*/
직각 이등변 삼각형 출력
도움 안쪽 루프와 바깥쪽 루프의 선언부를 유심히 보면서 분석해야한다. 변수가 몇부터 시작하는지, 제어식과 증가식이 어떻게 다르게 설정해야 하는지, 조건문은 어떻게 설정할지 유심히 생각하고 봐야 한다. 밑에 나열된 4개의 직각 이등변 삼각형 문제는 대표적인 이중 for문 알고리즘 문제이다. 답지를 보진 않았지만 난 머리가 나빠서 오래 걸렸다. 결국 이 알고리즘들을 생각하지 못했더라도 좌절하지 말자 유명 강사분도 이 알고리즘들을 처음 접했을 때 결국 풀어내지 못했다고 한다.
왼쪽 아래가 직각인 이등변 삼각형
사용자로부터 단 수를 입력받고, 왼쪽 아래가 직각인 이등변 삼각형
import java.util.Scanner;
public class Test{
static void triangleLB(int n)
{
for(int i = 0; i < n; ++i)
{
for(int j = 0; j <= i; ++j)
{
System.out.print("*");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nc;
do {
System.out.print("단 수 입력 : ");
nc = sc.nextInt();
}
while(nc<=0);
triangleLB(nc);
}
}
/*
단 수 입력 : 10
*
**
***
****
*****
******
*******
********
*********
**********
*/
답지 코드
static void triangleLB(int n) {
for (int i = 1; i <= n; i++) { // i행 (i = 1, 2, … ,n)
for (int j = 1; j <= i; j++) // i개의 '*'를 나타냄
System.out.print('*');
System.out.println(); // 개행(줄변환)
}
}
왼쪽 위가 직각인 이등변 삼각형
사용자로부터 단 수를 입력 받고, 왼쪽 위가 직각인 이등변 삼각형
import java.util.Scanner;
public class Test{
static void triangleLU(int n)
{
for(int i = n; i > 0; --i)
{
for(int j = 0; j < i; ++j)
{
System.out.print("*");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nc;
do {
System.out.print("단 수 입력 : ");
nc = sc.nextInt();
}
while(nc<=0);
triangleLU(nc);
}
}
/*
단 수 입력 : 10
**********
*********
********
*******
******
*****
****
***
**
*
*/
답지 코드
static void triangleLU(int n) {
for (int i = 1; i <= n; i++) { // i행 (i = 1, 2, … ,n)
for (int j = 1; j <= n - i + 1; j++) // n-i+1개의 '*'를 나타냄
System.out.print('*');
System.out.println(); // 개행(줄변환)
}
}
오른쪽 위가 직각인 이등변 삼각형
사용자로부터 단 수를 입력 받고, 오른쪽 위가 직각인 이등변 삼각형
import java.util.Scanner;
public class Test{
static void triangleRU(int n)
{
for(int i = 0; i < n; ++i)
{
for(int j = 0; j < n; ++j)
{
if(i<=j)System.out.print("*");
else System.out.print(" ");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nc;
do {
System.out.print("단 수 입력 : ");
nc = sc.nextInt();
}
while(nc<=0);
triangleRU(nc);
}
}
/*
단 수 입력 : 10
**********
*********
********
*******
******
*****
****
***
**
*
*/
답지 코드
static void triangleRU(int n) {
for (int i = 1; i <= n; i++) { // i행 (i = 1, 2, … ,n)
for (int j = 1; j <= i - 1; j++) // i-1개의 ' '를 나타냄
System.out.print(' ');
for (int j = 1; j <= n - i + 1; j++) // n-i+1개의 '*'를 나타냄
System.out.print('*');
System.out.println(); // 개행(줄변환)
}
}
오른쪽 아래가 직각인 이등변 삼각형
사용자로부터 단 수를 입력 받고, 오른쪽 아래가 직각인 이등변 삼각형
import java.util.Scanner;
public class Test{
static void triangleRB(int n)
{
for(int i = 1; i <= n; ++i)
{
for(int j = 1; j <= n; ++j)
{
if(n-j < i)System.out.print("*");
else System.out.print(" ");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nc;
do {
System.out.print("단 수 입력 : ");
nc = sc.nextInt();
}
while(nc<=0);
triangleRB(nc);
}
}
/*
단 수 입력 : 10
*
**
***
****
*****
******
*******
********
*********
**********
*/
답지 코드
static void triangleRB(int n) {
for (int i = 1; i <= n; i++) { // i행 (i = 1, 2, … ,ln)
for (int j = 1; j <= n - i; j++) // n-i개의 ' '를 나타냄
System.out.print(' ');
for (int j = 1; j <= i; j++) // i개의 '*'를 나타냄
System.out.print('*');
System.out.println(); // 개행(줄변환)
}
}
피라미드
도움 피라미드의 최하단은 2n-1이다. 피라미드의 중심축은 n-1이다. 중심축을 따라서 단이 늘어날수록 왼쪽과 오른쪽의 공백을 줄여주면 된다.
일반 피라미드
import java.util.Scanner;
public class Test{
static void spira(int n)
{
for(int i = 0; i < n; ++i)
{
for(int j = 0; j <= n+(n-1); ++j)
{
if(j<n-1-i) System.out.print(" ");
else if(j>n-1+i) System.out.print(" ");
else System.out.print("*");
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nc;
do {
System.out.print("단 수 입력 : ");
nc = sc.nextInt();
}
while(nc<=0);
spira(nc);
}
}
/*
단 수 입력 : 10
*
***
*****
*******
*********
***********
*************
***************
*****************
*******************
*/
답지 코드
static void spira(int n) {
for (int i = 1; i <= n; i++) { // i행 (i = 1, 2, … ,n)
for (int j = 1; j <= n - i + 1; j++) // n-i+1개의 ' '를 나타냄
System.out.print(' ');
for (int j = 1; j <= (i - 1) * 2 + 1; j++) // (i-1)*2+1개의 '*'를 나타냄
System.out.print('*');
System.out.println(); // 개행(줄변환)
}
숫자 피라미드
import java.util.Scanner;
public class Test{
static void spira(int n)
{
for(int i = 0; i < n; ++i)
{
for(int j = 0; j <= n+(n-1); ++j)
{
if(j<n-1-i) System.out.print(" ");
else if(j>n-1+i) System.out.print(" ");
else System.out.print((i+1) % 10);
}
System.out.println();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nc;
do {
System.out.print("단 수 입력 : ");
nc = sc.nextInt();
}
while(nc<=0);
spira(nc);
}
}
/*
단 수 입력 : 10
1
222
33333
4444444
555555555
66666666666
7777777777777
888888888888888
99999999999999999
0000000000000000000
*/
답지 코드
static void spira(int n){
for (int i = 1; i <= n; i++) { // i행 (i = 1, 2, … ,n)
for (int j = 1; j <= n - i + 1; j++) // n-i+1개의 ' '를 나타냄
System.out.print(' ');
for (int j = 1; j <= (i - 1) * 2 + 1; j++) // (i-1)*2+1개의 '*'를 나타냄
System.out.print(i % 10);
System.out.println(); // 개행(줄변환)
}
}
import java.util.Scanner;
public class Test{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int nc2;
System.out.println("두 자리 정수를 입력하세요");
do {
System.out.print("입력 : ");
nc2 = sc.nextInt();
}
while(nc2<10||nc2>100);
System.out.println("두 자리 정수를 입력하셨습니다.");
}
}
/*
두 자리 정수를 입력하세요
입력 : 5
입력 : 101
입력 : 556
입력 : 55
두 자리 정수를 입력하셨습니다.
*/
드모르간 법칙
위 예제에서 nc2 < 10 || nc2 > 100 는 드모르간 법칙에 의해 !(nc2 < 10 || nc2 > 100)와 같다.
드모르간 법칙 각 조건을 부정하고 논리곱을 논리합으로, 논리합을 논리곱으로 바꾸고 다시 전체를 부정하면 원래의 조건과 같다.
예를 들어 자본금 1000만원으로 사업을 시작했다고 하자(액면가 1000원 X 10000주 발행) 사업을 시작하고 흑자(이익잉여금)를 내지 못하고 적자(결손금)가 500만 원 발생했다면, 자본이 500만 원(자본금 1000만 원 - 결손금 500만 원)인 상태가 된다. 즉, 자본이 자본금보다 적어지는 상태이다. 이것은 자본잠식 상태이다. 자본잠식 상태가 길어지면 상장폐지가 되고, 완전자본잠식 상태가 되면 즉시 상장폐지가 되므로, 무상감자를 진행하여 자본잠식 상태를 벗어나는 것이다. 따라서 결손금 500만원을 없애기 위해서 자본금(주식 5000주)을 줄이는 것이다.(액면가 1000원 X 5000주 = 500만 원) 무상감자를 진행하고 나면 자본 500만 원, 자본금 500만 원이 되므로 자본잠식 상태를 벗어나게 된다.
무상감자를 하게 되면 당연히 주주들이 손해를 본다.(대주주, 개미들 전부 다)
주식회사에서 경영은 보통 대주주들이 하므로 대주주들은 할 말이 없다.
개미들은 무상감자를 반대하기도 애매한 상황이 된다. 왜냐하면 무상감자를 진행하지 않고, 자본잠식 상태가 계속 진행되면 자신들이 가지고 있는 주식이 휴지조각이 될 수 있기 때문이다.
무상감자를 한다는 것은 기업이 경영을 잘 못했다는 증거가 되므로 주식시장에서 악재로 작용한다.
사전 판단 반복문인 while문과 for문은 처음에 제어식을 평가한 결과가 0이면 루프 본문은 한 번도 실행되지 않는다. 이와 달리 사후 판단 반복문인 do-while문은 루프 본문이 반드시 한 번은 실행된다. 이것이 사전 판단 반복과 사후 판단 반복의 차이점이다.
음수 입력 방지하기
import java.util.Scanner;
public class Test{
static int SumFor(int n)
{
int sum = 0;
for(int i = 1; i <= n; ++i)sum += i;
return sum;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n;
do { //음수 입력 방지
System.out.print("양의 정수를 입력하세요 : ");
n = sc.nextInt();
}while(n<=0);
System.out.println("1부터 "+ n +"까지 합계 : " + SumFor(n));
}
}
/*
양의 정수를 입력하세요 : -5
양의 정수를 입력하세요 : 0
양의 정수를 입력하세요 : 100
1부터 100까지 합계 : 5050
*/
설명 do 블록은 처음에 무조건 실행되므로 정수를 출력 받고 while문의 제어식이 참(true)이면 do 블록을 다시 실행하게 된다. 즉, 음수를 입력하면 do 블록을 계속 실행하게 된다.
변수 a, b 입력받고 b - a를 출력하기
두 변수 a, b에 정수를 입력하고 b - a를 출력하는 프로그램 작성
(단, 변수 b에 입력한 값이 a이하면 변수 b의 값을 다시 입력하도록 유도)
package TestPackage;
import java.util.Scanner;
public class Test{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("정수 두 개를 입력하세요 : ");
int a = sc.nextInt();
int b;
b = sc.nextInt();
do {
if(a<b)break;
System.out.print("앞에 입력된 값보다 큰 값을 입력하세요 : ");
b = sc.nextInt();
}while(a>=b);
System.out.println(b-a);
}
}
/*
정수 두 개를 입력하세요 : 6 6
앞에 입력된 값보다 큰 값을 입력하세요 : 4
앞에 입력된 값보다 큰 값을 입력하세요 : 1
앞에 입력된 값보다 큰 값을 입력하세요 : 8
2
*/
설명 a와 b를 입력받고 a보다 b가 더 크면 루프를 탈출하고, a가 b보다 크거나 같으면 루프를 다시 돌게 된다.
입력받은 양의 정수의 자릿수 구하기
양의 정수를 입력하고 자릿수를 출력하는 프로그램을 작성하기
예를 들어 134를 입력하면 3을 출력하고, 1314를 입력하면 4를 출력하기
import java.util.Scanner;
public class Test{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n;
do {
System.out.print("양의 정수를 입력하세요：");
n = sc.nextInt();
} while (n <= 0);
int nc = 0;
while (n > 0) {
n /= 10;
nc++;
}
System.out.println(nc);
}
}
/*
양의 정수를 입력하세요：-66
양의 정수를 입력하세요：0
양의 정수를 입력하세요：68818473
8
*/
설명 사용자로부터 정수를 입력받아 n에 저장을 하고, n을 10으로 음수나 0이 될 때까지 나눈다. 10으로 나눌 때마다 자릿수를 저장하는 nc는 1씩 증가하게 된다. 결국 n이 음수 또는 0이 되면 루프를 탈출하고 nc를 출력한다.
import java.util.Scanner;
public class Test{
static int SumWile(int n)
{
int i = 1;
int sum = 0;
while(i <= n)
{
sum+=i;
++i;
}
return sum;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("정수를 입력하세요 : ");
int n = sc.nextInt();
System.out.println("1부터 "+ n +"까지 합계 : " + SumWile(n));
}
}
/*
정수를 입력하세요 : 100
1부터 100까지 합계 : 5050
*/
i 값이 n+1이 됨을 확인하기
위 코드에서 while문이 종료될 때 변수 i 값이 n+1이 됨을 확인하기(변수 i 값을 출력하도록)
import java.util.Scanner;
public class Test{
static int SumWile(int n)
{
int i = 1;
int sum = 0;
while(i <= n)
{
sum+=i;
++i;
}
System.out.println(i);
return sum;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("정수를 입력하세요 : ");
int n = sc.nextInt();
System.out.println("1부터 "+ n +"까지 합계 : " + SumWile(n));
}
}
/*
정수를 입력하세요 : 100
101
1부터 100까지 합계 : 5050
*/
설명 i는 n까지 증가가 된 후에도 ++i가 되었기 때문에 i는 n+1이 된다.
for문
import java.util.Scanner;
public class Test{
static int SumFor(int n)
{
int sum = 0;
for(int i = 1; i <= n; ++i)sum += i;
return sum;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("정수를 입력하세요 : ");
int n = sc.nextInt();
System.out.println("1부터 "+ n +"까지 합계 : " + SumFor(n));
}
}
/*
정수를 입력하세요 : 100
1부터 100까지 합계 : 5050
*/
import java.util.Scanner;
public class Test{
static void SumFor(int n)
{
int sum = 0;
for(int i = 1; i <= n; ++i) sum += i;
for(int i = 1; i <= n; ++i)
{
if(i == n)
{
System.out.print(i + " = ");
break;
}
System.out.print(i+" + ");
}
System.out.println(sum);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("정수를 입력하세요 : ");
int n = sc.nextInt();
SumFor(n);
}
}
/*
정수를 입력하세요 : 7
1 + 2 + 3 + 4 + 5 + 6 + 7 = 28
*/
설명 먼저 정수들의 합을 저장하고, 1부터 n까지의 수를 차례대로 출력하되, 중간에 " + " 문자열을 추가시킨다. for루프의 변수 i가 n과 같으면 i와 문자열 " = "를 출력시킨다. 그 후 처음에 구한 정수들의 합을 출력한다.
가우스 덧셈
1부터 10까지의 합은 (1+10) * 5 와 같은 방법으로 구할 수 있다. 가우스 덧셈이라는 방법을 이용하여 1부터 n까지의 정수 합을 구하는 프로그램 작성
가우스 덧셈 1부터 10까지 더한다고 할 때 첫 항과 마지막 항을 더한(1+10) 뒤 전체 항의 개수(10)를 2로 나눈 값(5)을 곱한다. (1+10) * (10 / 2) 이를 수식으로 나타내면 n * (n+1) / 2 이다.
import java.util.Scanner;
public class Test{
static int SumGauss(int n)
{
return (n*(n+1))/2;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("정수를 입력하세요 : ");
int n = sc.nextInt();
System.out.println(SumGauss(n));
}
}
/*
정수를 입력하세요 : 100
5050
*/
두 수 사이의 정수 합 구하기
정수 a, b를 포함하여 그 사이의 모든 정수의 합을 구하여 리턴하는 메서드를 작성
(a와 b의 대소 관계에 상관없이 합을 구하기(a=3, b=5이면 12를 리턴 / a=6, b=4이면 15를 리턴)
import java.util.Scanner;
public class Test{
static int Sumof(int a, int b)
{
int sum = 0;
if(b<a)
{ //swap
int tmp = a;
a = b;
b = tmp;
}
for(int i = a; i <= b; ++i) sum += i;
return sum;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int []arr = new int[2];
System.out.print("정수를 두 개를 입력하세요 : ");
for(int i = 0; i < 2; ++i)arr[i] = sc.nextInt();
System.out.println(Sumof(arr[0], arr[1]));
}
}
/*
정수를 두 개를 입력하세요 : 50 100
3825
*/
설명 매개 변수 a와 b중에 a가 더 크면 a와 b의 값을 바꾼다.(swap) 그 후 a부터 b까지의 수를 모두 더한 값을 리턴한다.
